def __init__(self, tc_name, global_config): """ Constructor """ UseCaseBase.__init__(self, tc_name, global_config) self._ftp_task_id = 0 self._ftp_filename = None self._ftp_direction = None # Read registrationTimeout from DeviceCatalog.xml self._registration_timeout = \ int(self._dut_config.get("registrationTimeout")) # Read callSetupTimeout from Device_Catalog.xml self._call_setup_timeout = \ int(self._dut_config.get("callSetupTimeout")) # Read the LAB_SERVER parameters from BenchConfig.xml self._server = \ global_config.benchConfig.get_parameters("LAB_SERVER") self._server_ip_address = self._server.get_param_value("IP") self._username = self._server.get_param_value("username") self._password = self._server.get_param_value("password") if self._server.has_parameter("ftp_path"): self._ftp_path = self._server.get_param_value("ftp_path") else: self._ftp_path = "" # Read ftp DIRECTION from testcase xml parameters self._direction = self._tc_parameters.get_param_value("DIRECTION") # Read the DL_FILE value from UseCase xml Parameter self._dlfilename = os.path.join( self._ftp_path, self._tc_parameters.get_param_value("DL_FILENAME")) # Read the UL_FILE value from UseCase xml Parameter self._ulfilename = os.path.join( self._ftp_path, self._tc_parameters.get_param_value("UL_FILENAME")) # Read CELLULAR_NETWORK parameters from BenchConfig.xml self._network = \ global_config.benchConfig.get_parameters("CELLULAR_NETWORK") self._apn = self._network.get_param_value("APN") self._ssid = self._network.get_param_value("SSID") # Retrieve valid bench name for 2G capability self._bench_name = get_nw_sim_bench_name("2G", global_config, self._logger) # Read NETWORK_SIMULATOR from BenchConfig.xml self._ns_node = \ global_config.benchConfig.get_parameters(self._bench_name) self._ns_IP_Lan1 = self._ns_node.get_param_value("IP_Lan1") self._ns_IP_Lan2 = \ self._ns_node.get_param_value("IP_Lan2") self._ns_DUT_IP_Address = \ self._ns_node.get_param_value("DUT_IP_Address") self._ns_DNS1 = self._ns_node.get_param_value("DNS1") self._ns_DNS2 = self._ns_node.get_param_value("DNS2") self._ns_Subnet_Mask = \ self._ns_node.get_param_value("Subnet_Mask") self._ns_Default_Gateway = \ self._ns_node.get_param_value("Default_Gateway") # Read the xml Template self._band_name = self._tc_parameters.get_param_value("CELL_BAND") self._bch_arfcn = int(self._tc_parameters.get_param_value("BCH_ARFCN")) self._pdtch_arfcn = \ int(self._tc_parameters.get_param_value("PDTCH_ARFCN")) self._cell_power = \ int(self._tc_parameters.get_param_value("CELL_POWER")) self._multislot = \ self._tc_parameters.get_param_value("MULTISLOT_CONFIG") self._ul_mcs = self._tc_parameters.get_param_value("UL_MCS") self._dl_mcs = self._tc_parameters.get_param_value("DL_MCS") self._ps_mcs = self._tc_parameters.get_param_value("PS_MCS") # Get UECmdLayer for Data and Voice call Use Cases self._networking_api = self._device.get_uecmd("Networking") self._modem_api = self._device.get_uecmd("Modem") self._voicecall_api = self._device.get_uecmd("VoiceCall") # set VOICE CODER RATE to FR_AMR_NB_1220 self._voice_coder_rate = "FR_AMR_NB_1220" # Read CALL_DURATION from test case xml file self._call_duration = \ int(self._tc_parameters.get_param_value("CALL_DURATION")) # Create cellular network simulator and retrieve 2G data interface self._ns = self._em.get_cellular_network_simulator(self._bench_name) # Shortcut to get Cell 2G parameters self._ns_cell_2g = self._ns.get_cell_2g() self._ns_data_2g = self._ns_cell_2g.get_data() self._ns_voice_call_2g = self._ns_cell_2g.get_voice_call()
def __init__(self, tc_name, global_config): """ Constructor """ UseCaseBase.__init__(self, tc_name, global_config) # Get TC parameters self._registration_timeout = \ int(self._dut_config.get("registrationTimeout")) # Read maxDlMultislotConfig from DeviceCatalog.xml max_dl_multislot_config = \ str(self._dut_config.get("maxDlMultislotConfig")) # Read maxUlMultislotConfig from DeviceCatalog.xml max_ul_multislot_config = \ str(self._dut_config.get("maxUlMultislotConfig")) # Get Lab Server parameters self._server = \ global_config.benchConfig.get_parameters("LAB_SERVER") self._server_ip_address = self._server.get_param_value("IP") self._username = self._server.get_param_value("username") self._password = self._server.get_param_value("password") if self._server.has_parameter("ftp_path"): self._ftp_path = self._server.get_param_value("ftp_path") else: self._ftp_path = "" # Read Cellular Network configuration self._network = \ global_config.benchConfig.get_parameters("CELLULAR_NETWORK") self._apn = self._network.get_param_value("APN") self._ssid = self._network.get_param_value("SSID") # Cell Tech is 2G self.ns_cell_tech = "2G" # Retrieve valid bench name for 2G capability self._bench_name = get_nw_sim_bench_name(self.ns_cell_tech, global_config, self._logger) # bench_name should be either NETWORK_SIMULATOR1 or NETWORK_SIMULATOR2 # In both cases, we need to retrieve the NS number (position in the bench config, either 1 or 2) self._ns_number = int(self._bench_name[-1]) # Read NETWORK_SIMULATOR from BenchConfig.xml self._ns_node = \ global_config.benchConfig.get_parameters(self._bench_name) # Read the Model of the NETWORK_SIMULATOR self._ns_model = self._ns_node.get_param_value("Model") self._ns_IP_Lan1 = self._ns_node.get_param_value("IP_Lan1") self._ns_IP_Lan2 = self._ns_node.get_param_value("IP_Lan2") self._ns_DUT_IP_Address = \ self._ns_node.get_param_value("DUT_IP_Address") self._ns_DUT_IP_Address2 = \ self._ns_node.get_param_value("DUT_IP_Address2", "") self._ns_DNS1 = self._ns_node.get_param_value("DNS1") self._ns_DNS2 = self._ns_node.get_param_value("DNS2") self._ns_Subnet_Mask = \ self._ns_node.get_param_value("Subnet_Mask") self._ns_Default_Gateway = \ self._ns_node.get_param_value("Default_Gateway") # Read the xml Template self._band_name = self._tc_parameters.get_param_value("CELL_BAND") # NS_CELL_REL self._ns_cell_rel = 7 self._cell_power = \ int(self._tc_parameters.get_param_value("CELL_POWER")) # Read the DIRECTION value from UseCase xml Parameter self._direction = self._tc_parameters.get_param_value("DIRECTION") # Read the Multislot Configuration value from UseCase xml Parameter # Check if this value is set to MAX or not multislot_config = \ str(self._tc_parameters.get_param_value("MULTISLOT_CONFIG", "MAX")) if multislot_config != "" or multislot_config != "None": if multislot_config == "MAX" and self._direction == "DL": self._multislot = max_dl_multislot_config elif multislot_config == "MAX" and self._direction == "UL": self._multislot = max_ul_multislot_config elif multislot_config == "MAX" and (self._direction == "" or self._direction is None): self._multislot = "D3U2" elif multislot_config != "MAX": self._multislot = multislot_config else: self._logger.info( "Unknown Multislot Configuration %s has been chosen" % multislot_config) self._dl_coding_scheme = self._tc_parameters.get_param_value("DL_CS") self._ul_coding_scheme = self._tc_parameters.get_param_value("UL_CS") # Get UECmdLayer for Data Use Cases self._networking_api = self._device.get_uecmd("Networking") self._modem_api = self._device.get_uecmd("Modem") # Create cellular network simulator and retrieve 2G data API self._ns = self._em.get_cellular_network_simulator(self._bench_name) self._ns_cell_2g = self._ns.get_cell_2g() self._ns_data_2g = self._ns_cell_2g.get_data() # Read the throughput targets self._throughput_targets = TelephonyConfigsParser("Throughput_Targets").\ parse_gprs_egprs_theoretical_targets("GPRS", self._multislot, self._dl_coding_scheme, self._ul_coding_scheme)
def __init__(self, tc_name, global_config): """ Initializes this instance. """ # Call inherited initializer UseCaseBase.__init__(self, tc_name, global_config) # Read registrationTimeout from Device_Catalog.xml self._registration_timeout = \ int(self._dut_config.get("registrationTimeout")) # Read IMS registration parameter self._ims_registration_timeout = self._tc_parameters.get_param_value( "IMS_REGISTRATION_TIMEOUT", default_cast_type=int) # Read the IMS password parameter self._digest_password = \ self._tc_parameters.get_param_value("IMS_DIGEST_PASSWORD", "") # Device phone number self._dut_phone_number = str(self._device.get_phone_number()) # If not valid, retrieve it from bench configuration file if self._dut_phone_number is None or self._dut_phone_number =="": self._dut_phone_number = \ self._retrive_parameter_bench_config(global_config, "PhoneNumberDut1") # Read the IMS configuration file path parameter self._ims_parameter_file = \ self._tc_parameters.get_param_value("IMS_PARAMETER_FILE") # Read the parameter for deregistration method self._deregistration_method = \ self._tc_parameters.get_param_value("DEREGISTRATION_METHOD", None) # Retrieve the IMS modem configuration procedure from bench configuration file # if defined try: self._ims_configure_modem_procedure = \ str(self._retrive_parameter_bench_config(global_config, "ImsModemConfiguration")) except AcsConfigException: self._ims_configure_modem_procedure = "AT-COMMANDS" # Read the IMS IP version parameter self._ip_version = \ self._tc_parameters.get_param_value("IP_VERSION", "IPV4") self.__xicfg_ip_version = None # Initialize an IMS Configurator instance self._generator = None # Read the authentication mode self.__authentication_mode = None authentication_mode = \ self._tc_parameters.get_param_value("IMS_AUTHENTICATION") if authentication_mode: authentication_mode = authentication_mode.lower() if authentication_mode in ("aka", "digest"): self.__authentication_mode = authentication_mode # Read the precondition parameter self.__preconditions = None preconditions = \ self._tc_parameters.get_param_value("IMS_PRECONDITIONS") if preconditions: preconditions = preconditions.lower() if preconditions in ("ietf", "3gpp"): self.__preconditions = preconditions # Create an attribute that keeps the list of configurations # to be applied. if self._ims_configure_modem_procedure == "IMS_ANDROID": self.__configurations = \ (self._ip_version, self.__preconditions, self.__authentication_mode) else: self.__configurations = \ (self.__authentication_mode + "-at_cmd", self.__preconditions + "-at_cmd", "flush" + "-at_cmd") # Read the IMS registration operation try: self._ims_reg_operation = \ self._retrive_parameter_bench_config(global_config, "ImsRegistrationOperation") except AcsConfigException: self._ims_reg_operation = \ str(self._tc_parameters.get_param_value("IMS_REGISTRATION_OPERATION", "REGISTER")) if "CHECK_ONLY" == self._ims_reg_operation: self._logger.info("IMS registration will only be checked") elif "SKIP_DEREGISTER" == self._ims_reg_operation: self._logger.info("IMS registration will be performed but de-registration will be skipped.") # Retrieve appropriate UE Cmd categories self._phone_system_api = self._device.get_uecmd("PhoneSystem") self._networking_api = self._device.get_uecmd("Networking") self._file_system_api = self._device.get_uecmd("File") self._modem_flashing_api = self._device.get_uecmd("ModemFlashing") self._modem_api = self._device.get_uecmd("Modem")
def set_up(self): """ Set up the test configuration """ # Call UseCaseBase Setup function UseCaseBase.set_up(self) # Check if we have the second phone available if self._phone2 is not None: if not self._phone2.is_available(): self._phone2.switch_on(simple_switch_mode=True) self._system_api2 = self._phone2.get_uecmd("System") else: # We are using this multi UC with only one phone error_msg = \ "This test case requires two phones to be executed !" self._logger.error(error_msg) raise AcsConfigException(AcsConfigException.INVALID_BENCH_CONFIG, error_msg) # Swap 2G 3G or 4G. if self._call_type == "2G": self._networking_api.set_preferred_network_type( PreferredNetwork.GSM_ONLY) elif self._call_type == "3G": self._networking_api.set_preferred_network_type( PreferredNetwork.WCDMA_ONLY) elif self._call_type == "4G": self._networking_api.set_preferred_network_type( PreferredNetwork.LTE_ONLY) else: if self._call_type not in "VOIP": msg = "wrong value of parameter CALL TYPE" self._logger.error(msg) raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg) # Audio Analyzer Initialization if self._audio_analyzer.initialization(self._device.get_phone_model(), self._test_type) != 0: error_msg = \ "Audio Analyzer Initialization Failed !" self._logger.error(error_msg) raise TestEquipmentException( TestEquipmentException.OPERATION_FAILED, error_msg) if self._acc_list.count("BLUETOOTH") > 0: # Get dut bt address self._dut_bt_address = self._bt_api.get_bt_adapter_address() # Push the first Bluetooth accessories in first l_bluetooth_acc_position = 0 for i in self._acc_list_split: if i.find("BLUETOOTH") != -1: # Initialization of _acc_type with the bluetooth accessories self._acc_type = i self._acc_list_split.insert(len(self._acc_list_split), i) self._acc_active_list_split.insert( len(self._acc_active_list_split), self._acc_active_list_split[l_bluetooth_acc_position]) self._call_volume_ref_list_split.insert( len(self._call_volume_ref_list_split), self. _call_volume_ref_list_split[l_bluetooth_acc_position]) self._call_volume_dut_list_split.insert( len(self._call_volume_dut_list_split), self. _call_volume_dut_list_split[l_bluetooth_acc_position]) break l_bluetooth_acc_position += 1 # Connect Bluetooth device if self._audio_analyzer.connect_bt(self._acc_type, self._dut_bt_address) != 0: error_msg = \ "Connect Bluetooth failed !" self._logger.error(error_msg) raise DeviceException(DeviceException.OPERATION_FAILED, error_msg) return Global.SUCCESS, "No errors"
def run_test(self): """ Execute the test """ UseCaseBase.run_test(self) # Setup embedded for all defined devices for device in DeviceManager().get_all_devices(): # get the signing keys from the device's BENCHCFG signing_key = device.get_config("appSigningKey", "") if not signing_key: error_msg = "appSigningKey parameter is not present in Device Catalog nor in Bench Config" raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, error_msg) system_api = device.get_uecmd("System") app_api = device.get_uecmd("AppMgmt") phone_system_api = device.get_uecmd("PhoneSystem") device_name = device.whoami().get("device", "") if not device_name: error_msg = "Device name cannot be found from device instance!" raise AcsConfigException( AcsConfigException.INSTANTIATION_ERROR, error_msg) # Boot the device if not booted and connect it if not device.is_available(): DeviceManager().boot_device(device_name) signing_key_name = None signing_key_folder = None # Get key to sign apps if necessary if not device.has_intel_os(): signing_key = None if signing_key: artifact_manager = self._em.get_artifact_manager( "ARTIFACT_MANAGER") artifact_manager.get_artifact(artifact_name=signing_key + ".pk8", transfer_timeout=10) local_artifact = artifact_manager.get_artifact( artifact_name=signing_key + ".x509.pem", transfer_timeout=10) signing_key_folder = os.path.dirname(local_artifact) signing_key_name = os.path.basename(signing_key) for agent_path in self._agent_paths: agent_path = agent_path.strip() if not agent_path: error_msg = "Split parameter error. An application path is empty. Did you forget a \";\" ?" raise AcsConfigException( AcsConfigException.INVALID_PARAMETER, error_msg) # check if path to ACS_AGENT exists if not os.path.exists(agent_path): error_msg = "Application not found {0} !".format( agent_path) raise AcsConfigException( AcsConfigException.INVALID_PARAMETER, error_msg) # if app signing is needed, do it now if signing_key_folder and signing_key_name: app_path = self.__sign_app(app_api, agent_path, signing_key_folder, signing_key_name) # actually install the app status, status_msg = app_api.install_device_app(app_path) if status != Global.SUCCESS: error_msg = "Unable to install application from {0} : {1}".format( app_path, status_msg) raise DeviceException(DeviceException.OPERATION_FAILED, error_msg) # disable app verification if device.is_rooted(): phone_system_api.set_verify_application(False) # Reboot device in order to "clean" the system after install device.reboot() # Initialize UI api self._ui_api.init() #disable SetupWizard verdict, msg = self._disable_wizard() if verdict != Global.SUCCESS: error_msg = "Unable to disable SetupWizard. Error Message: {0}".format( msg) raise DeviceException(DeviceException.OPERATION_FAILED, error_msg) return Global.SUCCESS, ""
def set_up(self): """ Set up the test configuration """ # Call use case base Setup function UseCaseBase.set_up(self) # Clear all data connections self._networking_api.clean_all_data_connections() time.sleep(self._wait_btwn_cmd) # Connect to equipment self._ns.init() # Set the equipment Application Format = "WCDMA" self._ns.switch_app_format("WCDMA") # Perform full preset self._ns.perform_full_preset() # Deactivate HSUPA and HSDPA capabilities self._ns_data_3g.set_edch_cell_capability("OFF") self._ns_data_3g.set_hsdpa_cell_capability("OFF") # Set cell off self._ns_cell_3g.set_cell_off() # 3G default cell setup RegUtil.setup_cell(self._ns_number, self._ns_model, "3G", self._band, self._ns_cell_rel, self._logger) # Set Frequency points using frequency list self._ns.configure_amplitude_offset_table() # Set cell power using CELL_POWER value self._ns_cell_3g.set_cell_power(self._cell_power) # Set serving cell to PACKET self._ns_cell_3g.set_cell_service("PACKET") # Set downlink UARFCN using DL_UARFCN value self._ns_cell_3g.set_band_and_dl_arfcn( "BAND" + str(self._band), self._dl_uarfcn) # Set cell on self._ns_cell_3g.set_cell_on() # Check Data Connection State => ATTACHED before timeout RegUtil.check_dut_data_connection_state_before_timeout("ATTACHED", self._ns_cell_3g, self._networking_api, self._logger, self._registration_timeout, flightmode_cycle=True, blocking=False) # Check registration state is connected using # registrationTimeout from Device_Catalog.xml self._modem_api.check_cdk_registration_bfor_timeout( self._registration_timeout) # Set the APN time.sleep(self._wait_btwn_cmd) self._logger.info("Setting APN " + str(self._apn) + "...") self._networking_api.set_apn(self._ssid, self._apn) # Activate PDP context time.sleep(self._wait_btwn_cmd) self._logger.info("Active PDP Context...") self._networking_api.activate_pdp_context(self._ssid) # Check Data Connection State => PDP Active before timeout self._ns_data_3g.check_data_connection_state("PDP_ACTIVE", self._registration_timeout, blocking=False) # Get RAT from Equipment network_type = self._ns_data_3g.get_network_type() # Check that DUT is registered on the good RAT self._modem_api.check_network_type_before_timeout(network_type, self._registration_timeout) return Global.SUCCESS, "No errors"
def __init__(self, tc_name, global_config): """ Constructor """ UseCaseBase.__init__(self, tc_name, global_config) self._oglconform = OGLConform(self._device) self._report_pathname = self._device.get_report_tree().get_report_path( ) self._output_filename = "%s/%s.csv" % ( self._report_pathname, os.path.basename(self.get_name())) self._output_filename_khronos = "%s/khronos_%s.csv" % ( self._report_pathname, os.path.basename(self.get_name())) # get TestCase parameters self._feature_name = str( self._tc_parameters.get_param_value("FEATURE_NAME", "")) self._diag_parameter = str( self._tc_parameters.get_param_value("DIAG_PARAMETER", "")).split(";") self._test_parameter = str( self._tc_parameters.get_param_value("TEST_PARAMETER", "")).replace("\n", "").split(";") self._khronos_parameter = str( self._tc_parameters.get_param_value("KHRONOS_PARAMETER", "")).split(";") self._remove_parameter = str( self._tc_parameters.get_param_value("REMOVE_PARAMS", "")).replace("\n", "").split(";") self._device_logdir = self._tc_parameters.get_param_value( "DEVICE_LOGDIR") self._cert_mode = self._tc_parameters.get_param_value("CERT_MODE") self._run_type = 'DRY' self.__tc_report = SecondaryTestReport( self._device.get_report_tree().get_report_path()) self._adb_remove = "adb shell rm -rf /data/app/" self._proc_name = "org.khronos.gl_cts" self._report_path = self._device.get_report_tree().get_report_path() self._khronos_object = KhronosApk(self._device, self._device_logdir, self._report_path, None) self.original_results_gfx_location = os.path.join( os.path.expanduser("~"), "test_output") self.acs_gfx_results = os.path.join( self._device.get_report_tree().get_report_path(), "gfx_results.zip") self._helper_scripts_path = 'OTC/TC/ACS/Graphics/Graphics/scripts' self._scripts_path = PathManager.absjoin(KhronosApk.TEST_SUITES_PATH, self._helper_scripts_path) self._activity_name = self._tc_parameters.get_param_value( "ACTIVITY_NAME") self._default_logging_dir = "/sdcard/" name_list = self.get_name().split("/") tcs_name = name_list[len(name_list) - 1] self._logs_folder_name = "gles_%s_logs" % tcs_name self._pull_logs_path = PathManager.absjoin(self._report_path, self._logs_folder_name) self._output_filename = "%s/%s.csv" % ( self._report_pathname, os.path.basename(self.get_name())) self._output_filename_khronos = "%s/khronos_%s.csv" % ( self._report_pathname, os.path.basename(self.get_name())) self._khronos = KhronosBin(self._device, self._report_pathname, self._logs_folder_name) # self._khronos_object = KhronosApk(self._device, self._device_logdir, self._report_path, self._activity_name) self._khronos_object = KhronosApk(self._device, self._device_logdir, self._pull_logs_path, self._activity_name)
def __init__(self, tc_name, global_config): # Call UseCaseBase init function. UseCaseBase.__init__(self, tc_name, global_config) # Get TC parameters self._registration_timeout = \ int(self._dut_config.get("registrationTimeout")) # Read NS_CELL_TECH from test case xml file self._ns_cell_tech = \ str(self._tc_parameters.get_param_value("CELL_TECH")) self._ns_cell_generation = self._ns_cell_tech if self._ns_cell_tech in ["3G", "HSPA"]: self._ns_cell_generation = "3G" # Read CELL_BAND from xml UseCase parameter file self._ns_cell_band = self._tc_parameters.get_param_value("CELL_BAND") # NS_CELL_REL self._ns_cell_rel = 7 # Read CELL_SERVICE from test case xml file self._ns_cell_service = \ str(self._tc_parameters.get_param_value("CELL_SERVICE")) # Read CELL_POWER from xml UseCase parameter file self._ns_cell_power = \ int(self._tc_parameters.get_param_value("CELL_POWER")) # Read the DARFCN value from UseCase xml Parameter self._ns_arfcn = \ int(self._tc_parameters.get_param_value("ARFCN")) self._cpc_tti_value = str( self._tc_parameters.get_param_value("CPC", "")) # Get the CPC parameters (only if user wants to use CPC feature) . if self._cpc_tti_value.strip().isdigit(): self._cpc_tti_value = int(self._cpc_tti_value) if self._cpc_tti_value != 2 and self._cpc_tti_value != 10: self._cpc_tti_value = None self._logger.warning( "Wrong CPC parameter : %s ; Value should be 2 or 10 " % self._cpc_tti_value) else: self._cpc_tti_value = None # Get Network configuration self._network = \ global_config.benchConfig.get_parameters("CELLULAR_NETWORK") self._apn_name = self._network.get_param_value("APN") self._apn_ssid = self._network.get_param_value("SSID") # Retrieve valid bench name for 3G capability self._bench_name = get_nw_sim_bench_name(self._ns_cell_generation, global_config, self._logger) # bench_name should be either NETWORK_SIMULATOR1 or NETWORK_SIMULATOR2 # In both cases, we need to retrieve the NS number (position in the bench config, either 1 or 2) self._ns_number = int(self._bench_name[-1]) # Read NETWORK_SIMULATOR from BenchConfig.xml self._ns_node = \ global_config.benchConfig.get_parameters(self._bench_name) # Retrieve the model of the equipment self._ns_model = self._ns_node.get_param_value("Model") # Retrieve the model IP addresses ns_ips = NetworkSimulatorIP(self._logger) ns_ips.setup_config(global_config, self._ns_number) (self._ns_ip_lan1, self._ns_ip_lan2, self._ns_ip_dut, self._ns_ip_dut2, self._ns_ip_dns1, self._ns_ip_dns2, self._ns_ip_subnet_mask, self._ns_ip_default_gateway) = ns_ips.get_config() # Get UECmdLayer for Data Use Cases self._modem_api = self._device.get_uecmd("Modem") self._phonesystem_api = self._device.get_uecmd("PhoneSystem") self._networking_api = self._device.get_uecmd("Networking") # Create cellular network simulator and retrieve 3G data API self._ns = self._em.get_cellular_network_simulator(self._bench_name) # Get server parameters self._server = \ global_config.benchConfig.get_parameters("LAB_SERVER") self._server_ip_address = self._server.get_param_value("IP") # Set the default duration of waiting after changing pdp context self._sleep_duration = 2 # Set the default duration of ping checking self._ping_check_duration = 10
def set_up(self): """ Set up the test configuration """ # Call use case base Setup function UseCaseBase.set_up(self) # Ensure flight mode off so that GSM sim operator info can be retrieved self._networking_api.set_flight_mode("off") time.sleep(self._wait_btwn_cmd) # Determinates the kind of registration state to wait # by comparing test case MCC/MNC parameters to sim MCC/MNC sim_info = self._modem_api.get_sim_operator_info() if sim_info["MCC"] != self._mcc or\ sim_info["MNC"] != self._mnc: self._wanted_reg_state = "roaming" self._networking_api.set_roaming_mode("ON") else: self._wanted_reg_state = "registered" # Clear all data connections self._networking_api.clean_all_data_connections() time.sleep(self._wait_btwn_cmd) # Enable flight mode self._networking_api.set_flight_mode("on") hpmln_message = "Expected network registration state to be %s while " \ % self._wanted_reg_state self._logger.info(hpmln_message) # Connect to equipment self._ns.init() # Set the equipment Application Format = "WCDMA" self._ns.switch_app_format("WCDMA") # Perform full preset self._ns.perform_full_preset() # Deactivate HSUPA and HSDPA capabilities self._ns_data_3g.set_edch_cell_capability("OFF") self._ns_data_3g.set_hsdpa_cell_capability("OFF") # Set cell off self._ns_cell_3g.set_cell_off() # Set Mobile Country Code (MCC) self._ns_cell_3g.set_mcc(self._mcc) # Set Mobile Network Code (MNC) self._ns_cell_3g.set_mnc(self._mnc) hpmln_message = "Expected network registration state to be %s while " \ "HPMLN coverage is %s, MCCODE is %s and MNCODE is %s" % ( str(self._wanted_reg_state), str(self._hplmn_coverage), str(self._mcc), str(self._mnc)) self._logger.info(hpmln_message) # 3G default cell setup RegUtil.setup_cell(self._ns_number, self._ns_model, "3G", self._band_name, self._ns_cell_rel, self._logger) # Set cell power using CELL_POWER value self._ns_cell_3g.set_cell_power(self._cell_power) # Set cell on self._ns_cell_3g.set_cell_on() # Disable airplane mode self._networking_api.set_flight_mode("off") # Check registration status before time out using # registrationTimeout value from Device_Catalog.xml time.sleep(self._wait_btwn_cmd) dut_imsi = self._modem_api.get_imsi(self._registration_timeout) RegUtil.check_dut_registration_before_timeout( self._ns_cell_3g, self._networking_api, self._logger, dut_imsi, self._registration_timeout) # Check registration state is connected using # registrationTimeout from Device_Catalog.xml (Non blocking # for this test if function isn't implemented on CDK) time.sleep(self._wait_btwn_cmd) self._modem_api.check_cdk_state_bfor_timeout( self._wanted_reg_state, self._registration_timeout) # Set the APN time.sleep(self._wait_btwn_cmd) self._logger.info("Setting APN " + str(self._apn) + "...") self._networking_api.set_apn(self._ssid, self._apn) # Activate PDP context time.sleep(self._wait_btwn_cmd) self._logger.info("Active PDP Context...") self._networking_api.activate_pdp_context(self._ssid) time.sleep(self._wait_btwn_cmd) # Check Data Connection State => PDP_ACTIVE before timeout self._ns_data_3g.check_data_connection_state( "PDP_ACTIVE", self._registration_timeout, blocking=False) # Get RAT from Equipment network_type = self._ns_data_3g.get_network_type() # Check that DUT is registered on the good RAT self._modem_api.check_network_type_before_timeout( network_type, self._registration_timeout) return Global.SUCCESS, "No errors"
def set_up(self): # Call UseCaseBase set_up function. UseCaseBase.set_up(self) # Disable data and PDP context self._networking_api.deactivate_pdp_context() # Enable flight mode self._networking_api.set_flight_mode("on") # Set the Network Simulators APIs instances self._set_ns_apis_instances() # Perform full preset self._ns.perform_full_preset() # Set cell off self._ns_cell.set_cell_off() # Set IP addresses self._ns.set_ip_addresses(self._ns_ip_lan1, self._ns_ip_lan2, self._ns_ip_subnet_mask, self._ns_ip_default_gateway, self._ns_ip_dut, self._ns_ip_dns1, self._ns_ip_dns2) # Call specific configuration functions # Some parameters are defined by function RegUtil.setup_cell(self._ns_number, self._ns_model, self._ns_cell_generation, self._ns_cell_band, self._ns_cell_rel, self._logger) # Set Cell Band and ARFCN using 3GSM_CELL_BAND # and 3GSM_ARFCN parameters # Set cell service using 3GSM_CELL_SERVICE parameter # Set Cell Power using 3GSM_CELL_POWER parameter # Set Cell LAC using 3GSM_LAC_VALUE parameter # Set Cell RAC using 3GSM_RAC_VALUE parameter self._ns_cell.configure_basic_cell_parameters(self._ns_cell_service, self._ns_cell_band, self._ns_arfcn, self._ns_cell_power) # Set CPC Feature if self._cpc_tti_value is not None: self._em.configure_equipments("CPCFeature%d" % self._ns_number, {"type": self._cpc_tti_value}) self._logger.info( "CPC Feature has been set on the equipment with TII equal to %s ms." % self._cpc_tti_value) if self._ns_cell_tech == "HSPA": hsdpa_cat = str(self._dut_config.get("maxDlHspaRab"))[9:] self._em.configure_equipments( "HSDPACategories%d" % self._ns_number, {"category": hsdpa_cat}) hsupa_cat = str(self._dut_config.get("maxUlHspaRab"))[9:] self._em.configure_equipments( "HSDPACategories%d" % self._ns_number, {"category": hsupa_cat}) # Set cell on self._ns_cell.set_cell_on() # Disable flight mode self._networking_api.set_flight_mode("off") # Set the APN in the DUT time.sleep(self._wait_btwn_cmd) self._logger.info("Setting APN " + str(self._apn_name) + "...") self._networking_api.set_apn(self._apn_ssid, self._apn_name) # Activate PDP context time.sleep(self._wait_btwn_cmd) self._logger.info("Active PDP Context...") self._networking_api.activate_pdp_context(self._apn_ssid, check=False) # Get RAT from Equipment network_type = self._ns_data.get_network_type() # Check that DUT is registered on the good RAT self._modem_api.check_network_type_before_timeout( network_type, self._registration_timeout) # Force screen on to avoid end of PDP context due to fast dormancy self._phonesystem_api.wake_screen() self._phonesystem_api.set_phone_screen_lock_on(1) if self._ns_data.get_data_connection_status() != "PDP_ACTIVE": self._ns_data.check_data_connection_state( "PDP_ACTIVE", self._registration_timeout, blocking=False) self._logger.info("Start continuous ping to " + self._server_ip_address) self._networking_api.start_continuous_ping(self._server_ip_address) return Global.SUCCESS, "No errors"
def run_test(self): """ Execute the test """ # Call UseCaseBase run_test function. UseCaseBase.run_test(self) self._logger.info("Check that the ping session still success") (ping_success, average_rtt) = \ self._networking_api.check_continuous_ping_success(self._ping_check_duration) if not ping_success: return Global.FAILURE, "Ping failed when it should not" else: self._logger.info( "Ping succeeded during %.0fs with average rtt of %.3f ms" % (self._ping_check_duration, average_rtt)) # De-activate pdp context self._networking_api.deactivate_pdp_context(self._apn_ssid) time.sleep(self._sleep_duration) self._logger.info("Check that the ping session fails") (ping_result, rtt) = self._networking_api.get_current_continuous_ping() if ping_result: return Global.FAILURE, "Ping succeeded when it should not" else: self._logger.info("Ping failed") # Check pdp is attached self._ns_data.check_data_connection_state("ATTACHED") self._logger.info("Check that the ping session still fails") ping_failed = self._networking_api.check_continuous_ping_failure( self._ping_check_duration) if not ping_failed: return Global.FAILURE, "Ping succeed when it should npt" else: self._logger.info("Ping failed during %.0fs" % self._ping_check_duration) # Re-activate pdp context self._networking_api.activate_pdp_context(self._apn_ssid) time.sleep(self._sleep_duration) self._logger.info("Check that the ping session success") (ping_result, rtt) = self._networking_api.get_current_continuous_ping() if not ping_result: return Global.FAILURE, "Ping failed when it should npt" else: self._logger.info("Ping succeeded") # Check pdp is transfering self._ns_data.check_data_connection_state(self._active_state) self._logger.info("Check that the ping session still success") (ping_success, average_rtt) = \ self._networking_api.check_continuous_ping_success(self._ping_check_duration) if not ping_success: return Global.FAILURE, "Ping succeeded when it should not" else: self._logger.info( "Ping succeeded during %.0fs with average rtt of %.3f ms" % (self._ping_check_duration, average_rtt)) return Global.SUCCESS, "No errors"
def __init__(self, tc_name, global_config): """ Constructor """ # Call LiveBTBase init function UseCaseBase.__init__(self, tc_name, global_config) # Get UECmdLayer self._bt_api = self._device.get_uecmd("LocalConnectivity") self._networking_api = self._device.get_uecmd("Networking") # Get TestCase parameters self._wifi_init_mode = self._tc_parameters.get_param_value("WIFI_INIT_MODE") self._bt_init_mode = self._tc_parameters.get_param_value("BT_INIT_MODE") self._nfc_init_mode = self._tc_parameters.get_param_value("NFC_INIT_MODE") self._nfc_beam_init_mode = self._tc_parameters.get_param_value("NFC_BEAM_INIT_MODE") self._hotspot_wifi_init_mode = self._tc_parameters.get_param_value("HOTSPOT_WIFI_INIT_MODE") self._hotspot_bt_init_mode = self._tc_parameters.get_param_value("HOTSPOT_BT_INIT_MODE") # Format TC parameter in order to have defined boolean or None values self._wifi_init_mode = str_to_bool_ex(self._wifi_init_mode) self._bt_init_mode = str_to_bool_ex(self._bt_init_mode) self._nfc_init_mode = str_to_bool_ex(self._nfc_init_mode) self._nfc_beam_init_mode = str_to_bool_ex(self._nfc_beam_init_mode) self._hotspot_wifi_init_mode = str_to_bool_ex(self._hotspot_wifi_init_mode) self._hotspot_bt_init_mode = str_to_bool_ex(self._hotspot_bt_init_mode) # Database of all functions to control and check features states self._DB = [{self._FEATURE_NAME: "WIFI", self._INIT_VALUE: self._wifi_init_mode, self._SET_ON: self._networking_api.set_wifi_power, self._SET_ON_PARAM: ['1'], self._SET_OFF: self._networking_api.set_wifi_power, self._SET_OFF_PARAM: ['0'], self._GET_STATE: self._networking_api.get_wifi_power_status, self._EXPECTED_ON: 1, self._EXPECTED_OFF: 0}, {self._FEATURE_NAME: "BT", self._INIT_VALUE: self._bt_init_mode, self._SET_ON: self._bt_api.set_bt_power, self._SET_ON_PARAM: ['1'], self._SET_OFF: self._bt_api.set_bt_power, self._SET_OFF_PARAM: ['0'], self._GET_STATE: self._bt_api.get_bt_power_status, self._EXPECTED_ON: str(BT_STATE.STATE_ON), # pylint: disable=E1101 self._EXPECTED_OFF: str(BT_STATE.STATE_OFF)}, # pylint: disable=E1101 {self._FEATURE_NAME: "NFC", self._INIT_VALUE: self._nfc_init_mode, self._SET_ON: self._bt_api.nfc_enable, self._SET_ON_PARAM: [], self._SET_OFF: self._bt_api.nfc_disable, self._SET_OFF_PARAM: [], self._GET_STATE: self._bt_api.get_nfc_status, self._EXPECTED_ON: "ON", self._EXPECTED_OFF: "OFF"}, {self._FEATURE_NAME: "NFC_BEAM", self._INIT_VALUE: self._nfc_beam_init_mode, self._SET_ON: self._bt_api.enable_nfc_beam, self._SET_ON_PARAM: [], self._SET_OFF: self._bt_api.disable_nfc_beam, self._SET_OFF_PARAM: [], self._GET_STATE: self._bt_api.get_nfc_beam_status, self._EXPECTED_ON: True, self._EXPECTED_OFF: False}, {self._FEATURE_NAME: "HOTSPOT_WIFI", self._INIT_VALUE: self._hotspot_wifi_init_mode, self._SET_ON: self._networking_api.set_wifi_hotspot, self._SET_ON_PARAM: ["on", self._WIFI_TETHERING_SSID, self._WIFI_TETHERING_SECURITY, self._WIFI_TETHERING_PASSPHRASE], self._SET_OFF: self._networking_api.set_wifi_hotspot, self._SET_OFF_PARAM: ['off'], self._GET_STATE: self._networking_api.get_wifi_hotspot_status, self._EXPECTED_ON: 1, self._EXPECTED_OFF: 0}, {self._FEATURE_NAME: "HOTSPOT_BT", self._INIT_VALUE: self._hotspot_bt_init_mode, self._SET_ON: self._bt_api.set_bt_tethering_power, self._SET_ON_PARAM: ['1'], self._SET_OFF: self._bt_api.set_bt_tethering_power, self._SET_OFF_PARAM: ['0'], self._GET_STATE: self._bt_api.get_bt_tethering_power, self._EXPECTED_ON: True, self._EXPECTED_OFF: False} ] self._apm_cycle_effect_config = dict() self._features_on = list() # Instantiate the Secondary Report object self._secondary_report = SecondaryTestReport(self._device.get_report_tree().get_report_path()) self._initial_flight_mode_state = 0
def run_test(self): """ Executes the test """ UseCaseBase.run_test(self) # Perform a first Voice Call to check that # the operation succeeds in nominal conditions self.__perform_voice_call() # Enable flight mode and wait # for the phone to settle down self._logger.info("Enabling Flight Mode.") # pylint: disable-msg=E1101 self._networking_api.set_flight_mode("on") time.sleep(self._settledown_duration) # Perform a new Voice Call which is expected to fail try: self.__perform_voice_call() except AcsBaseException as the_exception: # Handle expected failure self.__check_failure(the_exception, DeviceException, DeviceException.TIMEOUT_REACHED) except: # Handle non-exception failures exception_message = "Unexpected error: %s" % (str( sys.exc_info()[0])) raise DeviceException(DeviceException.INTERNAL_EXEC_ERROR, exception_message) # Remove annoying possible popups self.__remove_popups() # Perform a SMS send which is also expected to fail try: self.__send_sms() except BaseException as the_exception: # We may have to go back on the home screen # to remove pop up message # We give the UE Command 5 seconds to do its job. self._device.run_cmd( "adb shell input keyevent %s" % LiveSmsVcFlightMode.KEYCODE_HOME, 5) # Handle expected failure self.__check_failure(the_exception, DeviceException, DeviceException.PHONE_OUTPUT_ERROR) except: # Handle non-exception failures exception_message = "Unexpected error: %s" % \ (str(sys.exc_info()[0])) raise DeviceException(DeviceException.INTERNAL_EXEC_ERROR, exception_message) # Remove annoying possible popups self.__remove_popups() # Disable flight mode and wait # for the phone to settle down self._logger.info( "Disabling Flight Mode.") # pylint: disable-msg=E1101 self._networking_api.set_flight_mode("off") time.sleep(self._settledown_duration) # Remove annoying possible popups self.__remove_popups() # We wait a little longer for the DUT to camp time.sleep(self._settledown_duration) # Perform another Voice Call to check that # the Flight Mode has actually been disabled self.__perform_voice_call() return Global.SUCCESS, "No errors"
def run_test(self): """ Execute the test """ # Run UC base run_test UseCaseBase.run_test(self) # Open the configuration file in read-only mode config_file = open(self._nvm_config_file_path, 'r') # Initialize global verdict and return message return_code = None return_message = None # Read NVM configuration file line by line for line in config_file: # Check whether this line shall be tested or not if line.startswith(self._prefixes) and line.find("=") != -1: self._logger.debug("Checking line: %s." % line) # Retrieve both the property and its value (config_element, element_value) = line.split("=") # Store the expected result for later use element_value = element_value.translate(None, "\r\n") # Build the corresponding AT command to send to the modem at_command = "at@%s?" % config_element self._logger.debug("Preparing AT command: %s" % at_command) self._logger.debug("Value to check: '%s'" % element_value) # Issue an AT command to the modem self._at_proxy_serial.write("%s\r\n" % at_command) # Initialize loop interation values answer_complete = False answer_line = None full_answer = "" # Read maximum tries maximum_tries = 10 # Read current try current_try = 0 while not answer_complete and current_try <= maximum_tries: # Update current try current_try += 1 # Read a line answer_line = self._at_proxy_serial.readline() # Remove unwanted characters answer_line = answer_line.translate(None, "\r\n") # Ignore the line if empty or None if answer_line is None or answer_line == "": continue else: if answer_line in ("ERROR", "OK"): answer_complete = True else: self._logger.debug("Got modem response: '%s'" % answer_line) full_answer += answer_line # Compare with the expected result if element_value not in full_answer: # If the values do not match message = "Modem value for '%s' is: '%s' (expected '%s')" % \ (config_element, str(full_answer), element_value) # Log an error self._logger.error(message) # Update the global verdict if required return_code = Global.FAILURE else: self._logger.debug("Ignoring line: %s" % line) # Update the verdict if no error occured if return_code is None: return_code = Global.SUCCESS return_message = "No error." else: # If return code is not None # then it means that an error occured. # We will return the last error message return_message = "Last error was: %s" % message # In any case close the file opened in read-only mode config_file.close() # Return the verdict of the flash return return_code, return_message
def __init__(self, tc_name, global_config): # Call UseCaseBase init function. UseCaseBase.__init__(self, tc_name, global_config) # init following variable with it's default value: self._wanted_reg_state = "registered" # Read the configuration from test case self._registration_timeout = \ int(self._dut_config.get("registrationTimeout")) # Read MMS APN parameters from BenchConfig.xml to use NowSMS Server self._mms_apn = \ global_config.benchConfig.get_parameters("NOWSMS_SERVER") self._apn_ssid = self._mms_apn.get_param_value("SSID") self._apn_name = self._mms_apn.get_param_value("APN") self._apn_user = self._mms_apn.get_param_value("username") self._apn_password = self._mms_apn.get_param_value("password") self._apn_ip_address = self._mms_apn.get_param_value("IP") self._apn_port = self._mms_apn.get_param_value("APN_PORT") self._destination_number = self._mms_apn.get_param_value( "MMS_DESTINATION_NUMBER", "") # Compose the mmsc value using Now Sms Server URL, APN_PORT, APN_USER, APN_PASSWORD self._apn_mmsc = self._apn_ip_address + ":" + self._apn_port + "/" + self._apn_user + "=" + self._apn_password # Set apn type to "default,mms" according to UC definition (test of MO / MT MMS) self._apn_type = "default,mms" # Get NowSMS Server port self._nowsms_port = self._mms_apn.get_param_value("PORT") # Compose the complete NowSms Server URL with the connection port self._nowsms_url = self._apn_ip_address + ":" + self._nowsms_port # Get NOWSMS user name self._user_name = self._tc_parameters.get_param_value( "NOWSMS_USER_NAME") # Get NOWSMS user password self._user_password = self._tc_parameters.get_param_value( "NOWSMS_USER_PASSWORD") # Read NS_CELL_TECH from test case xml file self._cell_tech = \ str(self._tc_parameters.get_param_value("CELL_TECH", "3G")) # Read CELL_BAND from xml UseCase parameter file self._cell_band = self._tc_parameters.get_param_value("CELL_BAND") # NS_CELL_REL self._ns_cell_rel = 7 # Read CELL_SERVICE from test case xml file self._cell_service = \ str(self._tc_parameters.get_param_value("CELL_SERVICE")) # Read CELL_POWER from xml UseCase parameter file self._cell_power = \ int(self._tc_parameters.get_param_value("CELL_POWER")) # Read the DL_ARFCN value from UseCase xml Parameter self._arfcn = \ int(self._tc_parameters.get_param_value("ARFCN")) # Read the CELL_LAC value from UseCase xml Parameter self._lac = int(self._tc_parameters.get_param_value("LAC")) if self._lac is None: self._lac = 10 # Read the CELL_RAC value from UseCase xml Parameter self._rac = int(self._tc_parameters.get_param_value("RAC")) if self._rac is None: self._rac = 20 # Read the CELL_MCC value from UseCase xml Parameter self._mcc = int(self._tc_parameters.get_param_value("MCC")) if self._mcc is None: self._mcc = 1 # Read the CELL_MNC value from UseCase xml Parameter self._mnc = int(self._tc_parameters.get_param_value("MNC")) if self._mnc is None: self._mnc = 1 # Read optional MOVE_OUT_OF_COVERAGE parameter from UseCase xml Parameter self._move_out_of_coverage = self._tc_parameters.get_param_value( "MOVE_OUT_OF_COVERAGE", 0, int) if self._move_out_of_coverage != 1 and self._move_out_of_coverage != 2: self._move_out_of_coverage = 0 # Read optional OUT_OF_COVERAGE_TIMER parameter from UseCase xml Parameter self._out_of_coverage_timer = self._tc_parameters.get_param_value( "OUT_OF_COVERAGE_TIMER", 0, int) # Retrieve valid bench name for capability self._bench_name = get_nw_sim_bench_name(self._cell_tech, global_config, self._logger) # bench_name should be either NETWORK_SIMULATOR1 or NETWORK_SIMULATOR2 # In both cases, we need to retrieve the NS number (position in the bench config, either 1 or 2) self._ns_number = int(self._bench_name[-1]) # Read NETWORK_SIMULATOR from BenchConfig.xml self._ns_node = \ global_config.benchConfig.get_parameters(self._bench_name) # Create cellular network simulator self._em = EM() self._ns = self._em.get_cellular_network_simulator(self._bench_name) # Retrieve the model of the equipment self._ns_model = self._ns_node.get_param_value("Model") # Retrieve the model IP addresses ns_ips = NetworkSimulatorIP(self._logger) ns_ips.setup_config(global_config, self._ns_number) (self._ns_ip_lan1, self._ns_ip_lan2, self._ns_dut_ip_address, self._ns_dut_ip_address2, self._ns_dns1, self._ns_dns2, self._ns_subnet_mask, self._ns_default_gateway) = ns_ips.get_config() # Instantiate UECmd API self._modem_api = self._device.get_uecmd("Modem") self._phonesystem_api = self._device.get_uecmd("PhoneSystem") self._networking_api = self._device.get_uecmd("Networking") self._mms_messaging = self._device.get_uecmd("MmsMessaging")
def __init__(self, tc_name, global_config): """ Constructor """ UseCaseBase.__init__(self, tc_name, global_config) self._logger = LOGGER_TEST_SCRIPT logcat_cmd_line = self._device.get_config( "logcatCmdLine", "adb shell logcat -v threadtime") self._logcat_extract = os.path.join(Folders.REPORTS, "parserlogcat.log") self._logcat_analyzer = LogCatReaderThread( self._device, logger=self._logger, enable_writer=False, logcat_cmd_line=logcat_cmd_line) self._proc_name = "org.khronos.gl_cts" #parameter that says how you want to run the tests: dry or full #dry: run once, if it fails, log the result, close execution #full: if it fails, re-run from the last entry, log the results as you go self._run_type = self._tc_parameters.get_param_value("RUN_TYPE") #this parameter says if the run is in certification mode or not self._cert_mode = self._tc_parameters.get_param_value("CERT_MODE") #give the location on the device for the logs self._device_logdir = self._tc_parameters.get_param_value( "DEVICE_LOGDIR") #initializing the secondary test results #this is also where the intermediate and so on results must be pulled self._report_path = self._device.get_report_tree().get_report_path() self.__tc_report = SecondaryTestReport(self._report_path) #the sdcard is the default logging directory for the ES APK self._default_logging_dir = "/sdcard/" self._helper_scripts = 'OTC/TC/ACS/Graphics/Graphics/scripts' #this is also where the group and test lists must be pulled self._helper_scripts_gfx = PathManager.absjoin( KhronosApk.TEST_SUITES_PATH, self._helper_scripts) self._activity_name = self._tc_parameters.get_param_value( "ACTIVITY_NAME") self._group_list_filename = self._tc_parameters.get_param_value( "GROUPS_FILENAME") if self._tc_parameters.get_param_value("SINGLE_TEST_PARAM"): self._single_test_parameter = str( self._tc_parameters.get_param_value( "SINGLE_TEST_PARAM")).split(";") else: self._single_test_parameter = None name_list = self.get_name().split("/") tcs_name = name_list[len(name_list) - 1] self._logs_folder_name = "gles_%s_logs" % tcs_name self._pull_logs_path = PathManager.absjoin(self._report_path, self._logs_folder_name) if self._group_list_filename: self._group_list = PathManager.absjoin(self._helper_scripts_gfx, self._group_list_filename) else: self._group_list = self._helper_scripts_gfx # self._khronos_object = KhronosApk(self._device, self._device_logdir, self._report_path, self._activity_name) self._khronos_object = KhronosApk(self._device, self._device_logdir, self._pull_logs_path, self._activity_name) self._output_filename_khronos = "%s/khronos_%s.csv" % ( self._report_path, os.path.basename(self.get_name()))
def set_up(self): """ Set up the test configuration """ # Call use case base Setup function UseCaseBase.set_up(self) # Ensure flight mode off so that GSM sim operator info can be retrieved self._networking_api.set_flight_mode("on") time.sleep(self._wait_btwn_cmd) # Connect to equipment self._ns.init() # Set the equipment Application Format = "GSM/GPRS" self._ns.switch_app_format("GSM/GPRS") # Perform full preset self._ns.perform_full_preset() # Set cell off self._ns_cell_2g.set_cell_off() # 2G default cell setup RegUtil.setup_cell(self._ns_number, self._ns_model, "2G", self._band_name, self._ns_cell_rel, self._logger) # Set serving cell to GSM self._ns_cell_2g.set_cell_service("GSM") # Set cell power using CELL_POWER value self._ns_cell_2g.set_cell_power(self._cell_power) # Set cell on self._ns_cell_2g.set_cell_on() # Ensure flight mode off so that GSM sim operator info can be retrieved self._networking_api.set_flight_mode("off") # Check registration status before time out using # registrationTimeout value from Device_Catalog.xml time.sleep(self._wait_btwn_cmd) dut_imsi = self._modem_api.get_imsi(self._registration_timeout) # Start DUT registration RegUtil.check_dut_registration_before_timeout( self._ns_cell_2g, self._networking_api, self._logger, dut_imsi, self._registration_timeout) # Check registration state is connected using # registrationTimeout from Device_Catalog.xml (Non blocking # for this test if function isn't implemented on CDK) time.sleep(self._wait_btwn_cmd) self._modem_api.check_cdk_registration_bfor_timeout( self._registration_timeout) # Set the APN time.sleep(self._wait_btwn_cmd) self._logger.info("Setting APN " + str(self._apn) + "...") self._networking_api.set_apn(self._ssid, self._apn) # Activate PDP context but without check as in GSM, PDP can not be activated time.sleep(self._wait_btwn_cmd) self._logger.info("Active PDP Context...") self._networking_api.activate_pdp_context(self._ssid, check=False) # Get RAT from Equipment network_type = self._ns_data_2g.get_network_type() # Check that DUT is registered on the good RAT self._modem_api.check_network_type_before_timeout( network_type, self._registration_timeout) return Global.SUCCESS, "No errors"
def __init__(self, tc_name, global_config): self._ftp_path = None UseCaseBase.__init__(self, tc_name, global_config) AnyUsbTether.__init__(self, tc_name, global_config) self._throughput_targets = TelephonyConfigsParser("Throughput_Targets").\ parse_live_wcdma_targets()
def __init__(self, tc_name, global_config): """ Constructor """ # Call UseCase base Init function UseCaseBase.__init__(self, tc_name, global_config) # Read registrationTimeout from Device_Catalog.xml self._registration_timeout = \ int(self._dut_config.get("registrationTimeout")) # Read CELLULAR_NETWORK parameters from BenchConfig.xml self._network = \ global_config.benchConfig.get_parameters("CELLULAR_NETWORK") self._apn = self._network.get_param_value("APN") self._ssid = self._network.get_param_value("SSID") # Retrieve valid bench name for 3G capability self._bench_name = get_nw_sim_bench_name("3G", global_config, self._logger) # bench_name should be either NETWORK_SIMULATOR1 or NETWORK_SIMULATOR2 # In both cases, we need to retrieve the NS number (position in the bench config, either 1 or 2) self._ns_number = int(self._bench_name[-1]) # Read NETWORK_SIMULATOR from BenchConfig.xml self._ns_node = \ global_config.benchConfig.get_parameters(self._bench_name) # Retrieve the model of the equipment self._ns_model = self._ns_node.get_param_value("Model") # Read BAND from xml UseCase parameter file self._band = self._tc_parameters.get_param_value("CELL_BAND") # NS_CELL_REL self._ns_cell_rel = 7 # Read CELL_POWER from xml UseCase parameter file self._cell_power = \ int(self._tc_parameters.get_param_value("CELL_POWER")) # Read DL_UARFCN from xml UseCase parameter file self._dl_uarfcn = \ int(self._tc_parameters.get_param_value("DL_UARFCN")) # Read DATA_CODING_SCHEME from xml UseCase parameter file self._data_coding_sheme = \ self._tc_parameters.get_param_value("DATA_CODING_SCHEME") # Read SMS_TEXT from xml UseCase parameter file self._sms_text = self._tc_parameters.get_param_value("SMS_TEXT") # Read SMS_TRANSFER_TIMEOUT from xml UseCase parameter file self._sms_transfer_timeout = \ int(self._tc_parameters.get_param_value("SMS_TRANSFER_TIMEOUT")) dcs = DataCodingScheme(self._data_coding_sheme) dcs.decode() # Get number of bits per character setted in DCS self._nb_bits_per_char = dcs.compute_character_size() character_set = dcs.get_character_set() if character_set == "7BITS": self._content_type = "CTEX" else: self._content_type = "CDAT" # Instantiate Messaging UECmd for SMS UseCases self._messaging_api = self._device.get_uecmd("SmsMessaging") # Instantiate Modem UECmd for checking phone registration self._modem_api = self._device.get_uecmd("Modem") # Instantiate generic UECmd for camp self._networking_api = self._device.get_uecmd("Networking") # Create cellular network simulator and retrieve 3G mesaging # and 3G data interfaces self._ns = self._em.get_cellular_network_simulator(self._bench_name) self._ns_cell_3g = self._ns.get_cell_3g() self._ns_messaging_3g = self._ns_cell_3g.get_messaging() self._ns_data_3g = self._ns_cell_3g.get_data()
def set_up(self): (code, message) = UseCaseBase.set_up(self) if code == Global.SUCCESS: (code, message) = AnyUsbTether.set_up(self) return code, message
def run_test(self): """ Executes the test. """ UseCaseBase.run_test(self) # Format the command # The google test case result is stored inside GTEST_OUTPUT file cmd = "adb shell %s --gtest_output=\"xml:%s\"" % ( self._google_test_command, GTEST_OUTPUT) # Run the test result, output = self._device.run_cmd(cmd, self._google_test_timeout) # In all the cases store in ACS report folder google test command stdout # Build a report file path is ACS report folder txt_result_file_path = self.__build_report_file_name( self._google_test_command, "txt") with open(txt_result_file_path, "w") as text_file: text_file.write(output) if result == Global.SUCCESS: # Check adb command output after running google test if "Segmentation fault" in output: # Handle Segmentation fault error case # No xml report file generated => no copy to do in ACS report folder # Inform user that test is FAILED with Segmentation fault result = Global.FAILURE comment = "Segmentation Fault detected during google test command execution: " + \ self._google_test_command + " - see log file " + os.path.basename(txt_result_file_path) else: # Build a report file path is ACS report folder xml_result_file_path = self.__build_report_file_name( self._google_test_command, "xml") # Pull the google test result xml file on the ACS report folder self._device.pull(GTEST_OUTPUT, xml_result_file_path, ADB_PULL_FILE_TIMEOUT) # If we retrieve the google test command xml report file if os.path.isfile(xml_result_file_path): # Put all the test case data inside a dictionnary after parsing the google xml report file gtest_report_dict = {} status, msg = self.__google_test_xml_report_as_dict( xml_result_file_path, gtest_report_dict) if status: # Parse result file # Add to secondary reports all sub test cases result, comment = self.__parse_google_test_report_data( gtest_report_dict) else: result = Global.FAILURE comment = msg else: result = Global.FAILURE comment = "Cannot retrieve google test xml report file associated to test execution" % self._google_test_command if "ERROR:" in output: # Handle possible case where all test case are passed but an error is detected result = Global.FAILURE comment = "ERROR detected during google test command execution: " + \ self._google_test_command + " - see log file " + os.path.basename(txt_result_file_path) else: result = Global.FAILURE comment = "ISSUE detected during google test command execution: " + \ self._google_test_command + " - see log file " + os.path.basename(txt_result_file_path) return result, comment
def run_test(self): (code, message) = UseCaseBase.run_test(self) if code == Global.SUCCESS: (code, message) = AnyUsbTether.run_test(self) return code, message
def __init__(self, tc_name, global_config): """ Constructor """ # Call UseCaseBase Init function UseCaseBase.__init__(self, tc_name, global_config) # Create Audio Analyzer self._audio_analyzer = self._em.get_audio_analyzer("AudioAnalyzer") # Check if IO card is used self._use_io_card = str_to_bool( global_config.campaignConfig.get("isIoCardUsed")) # Create Whs if self._use_io_card: self._wired_headset = self._em.get_wired_headset("WiredHeadset") # Initialization of the test type self._test_type = "audioquality" # Initialization of accessories type self._acc_type = "None" self._previous_acc_type = "None" # Initialization of audio_analyzer_result saved self._audio_analyzer_result_save = 0 self._audio_analyzer_result_ul = 0 self._audio_analyzer_result_dl = 0 # Initialization of failed transition saved self._failed_transition_audio_pb = "" self._failed_transition_no_audio = "" # Initialization of _dut_bt_address self._dut_bt_address = "None" # Initialization of test result self._result_verdict = Global.SUCCESS # Initialization of the verdict comment self._verdict_comment = "Audio Quality test fail" # Read registrationTimeout from Device_Catalog.xml self._registration_timeout = \ int(self._dut_config.get("registrationTimeout")) # Read callSetupTimeout from Device_Catalog.xml self._call_setup_time = \ int(self._dut_config.get("callSetupTimeout")) # Read call origin type from test case xml file (str) self._call_origin_type = str( self._tc_parameters.get_param_value("CALL_ORIGIN_TYPE")) # Read accessories list from test case xml file (str) self._acc_list = str(self._tc_parameters.get_param_value("ACC_LIST")) # Split the accessories list, accessories separated by ',' self._acc_list = self._acc_list.strip('[] ') self._acc_list_split = self._acc_list.split(',') self._acc_list_split.reverse() # Read accessories active list from test case xml file (str) self._acc_active_list = str( self._tc_parameters.get_param_value("ACC_ACTIVE_LIST")) # Split the accessories active list, accessories separated by ',' self._acc_active_list = self._acc_active_list.strip('[] ') self._acc_active_list_split = self._acc_active_list.split(',') self._acc_active_list_split.reverse() # Call Stream Volume in percent self._call_stream_volume_dut_list = \ str(self._tc_parameters.get_param_value("CALL_VOLUME_DUT_LIST")) # Split the accessories list, accessories separated by ',' self._call_stream_volume_dut_list = self._call_stream_volume_dut_list.strip( '[] ') self._call_volume_dut_list_split = self._call_stream_volume_dut_list.split( ',') self._call_volume_dut_list_split.reverse() # Call Stream Volume in percent self._call_stream_volume_ref_list = \ str(self._tc_parameters.get_param_value("CALL_VOLUME_REF_LIST")) # Split the accessories list, accessories separated by ',' self._call_stream_volume_ref_list = self._call_stream_volume_ref_list.strip( '[] ') self._call_volume_ref_list_split = self._call_stream_volume_ref_list.split( ',') self._call_volume_ref_list_split.reverse() # Read call end type from test case xml file (str) self._call_end_type = str( self._tc_parameters.get_param_value("CALL_END_TYPE")) # Read call type from test case xml file (str) self._call_type = str(self._tc_parameters.get_param_value("CALL_TYPE")) # Read test call direction type from test case xml file (s tring) self._signal_tested_direction = \ str(self._tc_parameters.get_param_value("SIGNAL_TESTED_DIRECTION")) # Read duration type from test case xml file (int) if self._tc_parameters.get_param_value("DURATION"): self._call_duration = int( self._tc_parameters.get_param_value("DURATION")) else: # Call duration by default self._call_duration = 5 # Read Audio Analyzer parameters from bench config xml file (str) self._audio_analyzer_node = global_config.benchConfig.\ get_parameters("AudioAnalyzer") self._bt_remote_addr = self._audio_analyzer_node.get_param_value( "Bt_mac_addr") # Instantiate generic UECmd for voiceCall Ucs self._system_api = self._device.get_uecmd("System") self._networking_api = self._device.get_uecmd("Networking") # Bluetooth present in the list accessories if self._acc_list.count("BLUETOOTH") > 0: # Get UECmdLayer self._bt_api = self._device.get_uecmd("LocalConnectivity") # Load instance of the PHONE2 self._phone2 = DeviceManager().get_device("PHONE2") self._system_api2 = None self._acc_swap_type = self._tc_parameters.get_param_value( "ACC_SWAP_TYPE", 'Default') # Copy of accessories list self._temp_acc_list_split = None # Copy of volume list / active accessory list self._temp_call_volume_dut_list_split = None self._temp_call_volume_ref_list_split = None self._temp_acc_active_list_split = None
def tear_down(self): AnyUsbTether.tear_down(self) return UseCaseBase.tear_down(self)
def set_up(self): """ Initialize the test """ UseCaseBase.set_up(self) # Clear all data connections self._networking_api.clean_all_data_connections() time.sleep(self._wait_btwn_cmd) # Activate the flight mode. self._networking_api.set_flight_mode("on") # Connect to equipment self._ns.init() # Set the equipment application format GSM/GPRS self._ns.switch_app_format("GSM/GPRS") time.sleep(self._wait_btwn_cmd) # Perform a full preset self._ns.perform_full_preset() # Set cell off self._ns_cell_2g.set_cell_off() # Call specific configuration functions # Some parameters are defined by function RegUtil.setup_cell(self._ns_number, self._ns_model, self.ns_cell_tech, self._band_name, self._ns_cell_rel, self._logger) # Set serving cell to GPRS self._ns_cell_2g.set_cell_service("GPRS") # Set Frequency points using frequency list # Set Amplitude Offset correction using offset list # Turning amplitude offset state to ON self._ns.configure_amplitude_offset_table() # Set the equipment IP Address 1 self._ns.set_ip4_lan_address(self._ns_IP_Lan1) # Set the equipment IP_Lan2 to the equipment self._ns.set_ip4_lan_address2(self._ns_IP_Lan2) # Set the Equipment Subnet mask self._ns.set_ip4_subnet_mask(self._ns_Subnet_Mask) # Set the Equipment gateway self._ns.set_ip4_default_gateway(self._ns_Default_Gateway) # Set the DUT IP address 1 self._ns_data_2g.set_dut_ip_address(1, self._ns_DUT_IP_Address) # Set the DUT IP address 2 if not empty string. if self._ns_DUT_IP_Address2 != "": self._ns_data_2g.set_dut_ip_address(2, self._ns_DUT_IP_Address2) # Set the DUT DNS1 self._ns_data_2g.set_dut_primary_dns(self._ns_DNS1) # Set the DUT DNS2 self._ns_data_2g.set_dut_secondary_dns(self._ns_DNS2) # Set Cell Power using CELL_POWER parameter self._ns_cell_2g.set_cell_power(self._cell_power) # Set connection type to auto self._ns_data_2g.set_connection_type("AUTO") # Set the multislot configuration self._ns_data_2g.set_multislot_config(self._multislot) # Set the Coding Scheme (CS) self._ns_data_2g.set_pdtch_coding_scheme(self._dl_coding_scheme, self._ul_coding_scheme) # Set cell on self._ns_cell_2g.set_cell_on() # Phone has to see the cell off! self._modem_api.check_cdk_no_registration_bfor_timeout( self._registration_timeout) # Deactivate the flight mode. self._networking_api.set_flight_mode("off") # Check registration state is connected using # registrationTimeout from Device_Catalog.xml (Non blocking # for this test if function isn't implemented on CDK) self._modem_api.check_cdk_registration_bfor_timeout( self._registration_timeout) # Set the APN time.sleep(self._wait_btwn_cmd) self._logger.info("Setting APN " + str(self._apn) + "...") self._networking_api.set_apn(self._ssid, self._apn) # Activate PDP context time.sleep(self._wait_btwn_cmd) self._logger.info("Active PDP Context...") self._networking_api.activate_pdp_context(self._ssid, check=False) # Check Data Connection State => PDP Active before timeout self._ns_data_2g.check_data_connection_state( "PDP_ACTIVE", self._registration_timeout) # Get RAT from Equipment network_type = self._ns_data_2g.get_network_type() # Check that DUT is registered on the good RAT self._modem_api.check_network_type_before_timeout( network_type, self._registration_timeout) return Global.SUCCESS, "No errors"
def __init__(self, tc_name, global_config): """ Constructor """ UseCaseBase.__init__(self, tc_name, global_config)
def set_up(self): """ Initialize the test """ # Call inherited set_up method UseCaseBase.set_up(self) # Check the value for the IMS operation parameter if self._ims_reg_operation not in ("REGISTER", "CHECK_ONLY", "SKIP_DEREGISTER"): raise AcsConfigException( AcsConfigException.INVALID_PARAMETER, "Invalid parameter value for '%s' (%s)" % ( "IMS_REGISTRATION_OPERATION", str(self._ims_reg_operation))) # Perform operation according the the IMS operation parameter if self._ims_reg_operation in ("REGISTER", "SKIP_DEREGISTER"): # De-register for IMS services (verdict, message) = self._perform_ims_deregistration() if verdict == Global.FAILURE: raise AcsToolException( AcsToolException.OPERATION_FAILED, message) # Generate the configuration and flush the parameters # to the NVM. # We force the 'flush' configurations. self._generator = ImsConfigGenerator( self._ims_parameter_file, None, None, self._logger) # Check the value for the IP_VERSION parameter if self._ip_version not in ("IPV4", "IPV6", "IPV4V6"): raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, "Invalid parameter value for '%s' (%s)" % ("IP_VERSION", str(self._ip_version))) if self._ims_reg_operation in ("REGISTER", "SKIP_DEREGISTER"): # Set the APN for IPV6 or IPV4V6 if self._ip_version in ("IPV6", "IPV4V6"): # Modify the default values for APN configuration depending on the IP version ipv6_apn_values = self.C4I_DEFAULT_IPV4_APN_CONFIG.copy() ipv6_apn_values["apn"] = self.APN_VALUES[self._ip_version] ipv6_apn_values["protocol"] = self._ip_version # Update the APN configuration self._logger.info("Setting the APN configuration for %s protocol." % self._ip_version) self._networking_api.update_apn(ipv6_apn_values) # Default case - IPV4 else: self._logger.info("APN configuration is the default one, for %s protocol." % self._ip_version) # Configure value for +XICFG command depending on the IP version self.__xicfg_ip_version = str(self.XICFG_IP_VERSION[self._ip_version]) # Prior to anything let us check we are registered to LTE first self._modem_api.check_rat_with_pref_network( PreferredNetwork.LTE_ONLY, self._registration_timeout) # Apply the IMS configuration self._generate_configuration() # Set up is done correctly return (Global.SUCCESS, "No errors")
def set_up(self): """ Setting up the test """ # Call UseCaseBase set_up function. UseCaseBase.set_up(self) # Ensure flight mode off so that GSM sim operator info can be retrieved self._networking_api.set_flight_mode("off") time.sleep(self._wait_btwn_cmd) # Determinate the kind of registration state to wait # by comparing test case MCC/MNC parameters to sim MCC/MNC sim_info = self._modem_api.get_sim_operator_info() if sim_info["MCC"] != self._mcc or\ sim_info["MNC"] != self._mnc: self._wanted_reg_state = "roaming" self._networking_api.set_roaming_mode("ON") else: self._wanted_reg_state = "registered" # Clear all data connections self._networking_api.clean_all_data_connections() time.sleep(self._wait_btwn_cmd) # Enable flight mode self._networking_api.set_flight_mode("on") # Instantiate Network Simulator APIs and # Initialize the Network Simulator self.set_ns_apis_instances() # Perform full preset self._ns.perform_full_preset() # Set cell off self._ns_cell.set_cell_off() # Set the Equipment IP Address 1 self._ns.set_ip4_lan_address(self._ns_ip_lan1) # Set the equipment IP_Lan2 to the equipment self._ns.set_ip4_lan_address2(self._ns_ip_lan2) # Set the Equipment Subnet mask self._ns.set_ip4_subnet_mask(self._ns_subnet_mask) # Set the Equipment gateway self._ns.set_ip4_default_gateway(self._ns_default_gateway) # Set the DUT IP address 1 self._ns_data.set_dut_ip_address(1, self._ns_dut_ip_address) # Set the DUT IP address 2 if not empty str. if self._ns_dut_ip_address2 != "": self._ns_data.set_dut_ip_address(2, self._ns_dut_ip_address2) # Set HTTP Input ON for Nowsms # Set HTTP output ON for Nowsms self._ns.set_sms_http("ON", "ON") # Call specific configuration functions RegUtil.setup_cell(self._ns_number, self._ns_model, self._cell_tech, self._cell_band, self._ns_cell_rel, self._logger) # Set Cell Band and ARFCN using CELL_BAND # and ARFCN parameters # Set cell service using CELL_SERVICE parameter # Set Cell Power using CELL_POWER parameter # Set Cell LAC using LAC parameter # Set Cell RAC using RAC parameter # Set Cell MCC using MCC parameter # Set Cell MNC using MNC parameter self._ns_cell.configure_basic_cell_parameters( self._cell_service, self._cell_band, self._arfcn, self._cell_power, self._lac, self._rac, self._mcc, self._mnc) # Set cell on self._ns_cell.set_cell_on() # Disable flight mode self._networking_api.set_flight_mode("off") # Set the MMS APN in the DUT time.sleep(self._wait_btwn_cmd) self._logger.info("Setting APN " + str(self._apn_name) + "...") self._networking_api.set_apn(self._apn_ssid, self._apn_name, self._apn_user, self._apn_password, protocol=None, mmsc=self._apn_mmsc, apn_type=self._apn_type) # Activate PDP context time.sleep(self._wait_btwn_cmd) self._logger.info("Active PDP Context...") self._networking_api.activate_pdp_context(self._apn_ssid, check=False) # Check DUT is register verdict, output = self._check_network_registration() if verdict == Global.FAILURE: return verdict, output # Set display to "on" self._phonesystem_api.display_on() return Global.SUCCESS, "No error"
def run_test(self): UseCaseBase.run_test(self) test = self._tc_parameters.get_param_value("test") serial = self._device.retrieve_serial_number() adb_server_port = self._tc_parameters.get_param_value( "adb-server-port", default_value=None) adb_local_port = self._tc_parameters.get_param_value( "adb-local-port", default_value=None) script_args = self._tc_parameters.get_param_value("script-args", default_value=None) # Set Parameters specific to PHONE1 from benchConfig to script-args phone_number, sim_pin, wrong_pin, puk_code, carrier_name, voicemail_number = ( None, ) * 6 try: phone_number = self._global_conf.deviceConfig['PHONE1'].phoneNumber except Exception: pass if phone_number: if not script_args: script_args = "number={0}".format(phone_number) else: script_args += " number={0}".format(phone_number) try: sim_pin = self._global_conf.deviceConfig['PHONE1'].simPin except Exception: pass if sim_pin: if not script_args: script_args = "sim_pin={0}".format(sim_pin) else: script_args += " sim_pin={0}".format(sim_pin) try: wrong_pin = self._global_conf.deviceConfig['PHONE1'].wrongPin except Exception: pass if wrong_pin: if not script_args: script_args = "wrong_pin={0}".format(wrong_pin) else: script_args += " wrong_pin={0}".format(wrong_pin) try: puk_code = self._global_conf.deviceConfig['PHONE1'].pukCode except Exception: pass if puk_code: if not script_args: script_args = "puk_code={0}".format(puk_code) else: script_args += " puk_code={0}".format(puk_code) try: carrier_name = self._global_conf.deviceConfig['PHONE1'].carrierName except Exception: pass if carrier_name: if not script_args: script_args = "carrier_name={0}".format(carrier_name) else: script_args += " carrier_name={0}".format(carrier_name) try: voicemail_number = self._global_conf.deviceConfig[ 'PHONE1'].voiceMailNumber except Exception: pass if voicemail_number: if not script_args: script_args = "voicemail_number={0}".format(voicemail_number) else: script_args += " voicemail_number={0}".format(voicemail_number) # --------------------------------------------------------------------- serial2 = None # save the serialNumber if it is defined try: serial2 = self._global_conf.deviceConfig['PHONE2'].serialNumber except Exception: # the parameter is not defined; it will remain set to None pass if serial2 != None and serial2 != "": if script_args == None: script_args = "serial2={0}".format(serial2) else: script_args += " serial2={0}".format(serial2) # --------------------------------------------------------------------- serial3 = None # save the serialNumber if it is defined try: serial3 = self._global_conf.deviceConfig['PHONE3'].serialNumber except Exception: # the parameter is not defined; it will remain set to None pass if serial3 != None and serial3 != "": if script_args == None: script_args = "serial3={0}".format(serial3) else: script_args += " serial3={0}".format(serial3) # --------------------------------------------------------------------- serial4 = None # save the serialNumber if it is defined try: serial4 = self._global_conf.deviceConfig['PHONE4'].serialNumber except Exception: # the parameter is not defined; it will remain set to None pass if serial4 != None and serial4 != "": if script_args == None: script_args = "serial4={0}".format(serial4) else: script_args += " serial4={0}".format(serial4) media_path = self._tc_parameters.get_param_value("media-path", default_value=None) apks = self._tc_parameters.get_param_value("apks", default_value=None) timeout = self._tc_parameters.get_param_value("timeout", default_value=1800, default_cast_type=int) wifi_ap_name = self._device.get_config("WiFi_Support_Ap_Name") if wifi_ap_name != None: if script_args != None: # replace the given ap_name if it exists in script_args if "ap_name" in script_args: script_args = re.sub(r"ap_name=[-\w]+", r"ap_name=" + wifi_ap_name, script_args) else: script_args += " ap_name=" + wifi_ap_name #else: #script_args = "ap_name=" + wifi_ap_name # get the access point from bench config (ip and user name) ap_type = None ap_ip = None ap_username = None try: self._configurable_ap = self._em.get_computer("AccessPoint") except: self._logger.warning( "Invalid parameter for AccessPoint in Bench Config. " "Please update the AP Equipment name with: " "name='AccessPoint' and add the type of the AP " "'ddwrt_atheros' or 'ddwrt_broadcom'") try: ap_type = self._global_conf.benchConfig.get_parameters( "AccessPoint").get_dict()["type"]["value"] except: self._logger.warning( "'type' parameter missing for 'AccessPoint. Please update the AP Equipment with: " "parameter 'type' with 'value' 'ddwrt_atheros' or 'ddwrt_broadcom'" ) try: ap_ip = self._global_conf.benchConfig.get_parameters( "AccessPoint").get_dict()["IP"]["value"] ap_username = self._global_conf.benchConfig.get_parameters( "AccessPoint").get_dict()["username"]["value"] except: self._logger.warning( "'IP' or 'username' parameter missing for 'AccessPoint. Please update the AP Equipment with: " "parameter 'IP' with '192.168.1.1' or something similar, parameter 'username' with the user name" ) # add ap_type to script_args as ap_module if ap_type != None: if ap_type == "ddwrt_broadcom": ap_type = "ddwrt" if script_args != None: if "ap_module" in script_args: # replace the value script_args = re.sub(r"ap_module=[-\w]+", r"ap_module=" + ap_type, script_args) else: script_args += " ap_module={0}".format(ap_type) else: script_args = "ap_module={0}".format(ap_type) # add ap_ip to script_args if ap_ip != None: if script_args != None: if "ap_ip" in script_args: # replace the value script_args = re.sub(r"ap_ip=[\d\.]+", r"ap_ip=" + ap_ip, script_args) else: script_args += " ap_ip={0}".format(ap_ip) else: script_args = "ap_ip={0}".format(ap_ip) # add ap_username to script_args if ap_username != None: if script_args != None: if "ap_username" in script_args: # replace the value script_args = re.sub(r"ap_username=[-\w]+", r"ap_username="******" ap_username={0}".format(ap_username) else: script_args = "ap_username={0}".format(ap_username) # get the Internet Connected AP name & password from bench config net_ap_ssid = self._device.get_config("WiFi_Connection_Ap_Name") net_ap_password = self._device.get_config("WiFi_Connection_Passwd") net_ap_security = self._device.get_config( "WiFi_Connection_Security_Mode") wv_toolbox = self._device.get_config("WV_Tool_Box") wv_keybox = self._device.get_config("WV_Key_Box") android_build_top = self._device.get_config("Android_Build_Top") boot_img = self._device.get_config("Boot_Img") if net_ap_ssid: # replace the given ap_name if it exists in script_args net_ap_ssid = net_ap_ssid.replace(" ", "___") # by default, when the SSID contains white spaces, it is split into composing words, # and only the 1st one is passed to script args, which breaks the configuration # therefore, we temporarily replace spaces with three underscores if script_args: if "net_ap_ssid" in script_args: script_args = re.sub(r"net_ap_ssid=[-\w]+", r"net_ap_ssid={}".format(net_ap_ssid), script_args) else: script_args += " net_ap_ssid=" + net_ap_ssid + " " else: script_args = " net_ap_ssid=" + net_ap_ssid + " " if net_ap_password: if script_args: if "net_ap_password" in script_args: # replace the given passphrase if it exists in script_args script_args = re.sub( r"net_ap_password=[.^\s]+", r"net_ap_password="******" net_ap_password="******" net_ap_password="******"net_ap_security" in script_args: # replace the given security mode if it exists in script_args script_args = re.sub( r"net_ap_security=[-\w]+", r"net_ap_security=" + net_ap_security, script_args) else: script_args += " net_ap_security=" + net_ap_security + " " else: script_args = " net_ap_security=" + net_ap_security + " " if wv_toolbox: # replace the given wv_toolbox if it exists in script_args wv_toolbox = wv_toolbox.replace(" ", "___") if script_args: if "wv_toolbox" in script_args: script_args = re.sub(r"wv_toolbox=[-\w]+", r"wv_toolbox={}".format(wv_toolbox), script_args) else: script_args += " wv_toolbox=" + wv_toolbox + " " else: script_args = " wv_toolbox=" + wv_toolbox + " " if wv_keybox: if script_args: if "wv_keybox" in script_args: # replace the given wv_keybox if it exists in script_args script_args = re.sub(r"wv_keybox=[.^\s]+", r"wv_keybox=" + wv_keybox, script_args) else: script_args += " wv_keybox=" + wv_keybox else: script_args = " wv_keybox=" + wv_keybox if android_build_top: # replace the given android_build_top if it exists in script_args android_build_top = android_build_top.replace(" ", "___") if script_args: if "android_build_top" in script_args: script_args = re.sub( r"android_build_top=[-\w]+", r"android_build_top={}".format(android_build_top), script_args) else: script_args += " android_build_top=" + android_build_top + " " else: script_args = " android_build_top=" + android_build_top + " " if boot_img: # replace the given boot_img if it exists in script_args boot_img = boot_img.replace(" ", "___") if script_args: if "boot_img" in script_args: script_args = re.sub(r"boot_img=[-\w]+", r"boot_img={}".format(boot_img), script_args) else: script_args += " boot_img=" + boot_img + " " else: script_args = " boot_img=" + boot_img + " " # check if there is an "Equipment" named "RELAY" self._relay = None try: self._relay = self._global_conf.benchConfig.get_parameters("RELAY") except: try: self._relay = self._global_conf.benchConfig.get_parameters( "IO_CARD") except: pass script_args_to_add = "" if self._relay: # get all existing attributes of the relay relay_attributes = self._relay.get_dict() if "Model" in relay_attributes: script_args_to_add += "relay_type={} ".format( relay_attributes["Model"]["value"]) if "ComPort" in relay_attributes: script_args_to_add += "relay_port={} ".format( relay_attributes["ComPort"]["value"]) if "SwitchOnOff" in relay_attributes: script_args_to_add += "power_port={} ".format( relay_attributes["SwitchOnOff"]["value"]) if "VolumeUp" in relay_attributes: script_args_to_add += "v_up_port={} ".format( relay_attributes["VolumeUp"]["value"]) if "VolumeDown" in relay_attributes: script_args_to_add += "v_down_port={} ".format( relay_attributes["VolumeDown"]["value"]) if "USBVCCut" in relay_attributes: script_args_to_add += "USB_VC_cut={} ".format( relay_attributes["USBVCCut"]["value"]) script_args_to_add += "flash_files={}".format(Paths.FLASH_FILES) if script_args_to_add != "": if not script_args: script_args = "" script_args += " " + script_args_to_add ui_handlers_group = self._device.get_config("UI_Handlers_Group", default_value=None) if ui_handlers_group: os.environ['TESTLIB_UI_HANDLERS_GROUP'] = ui_handlers_group # create process for each test output, error = self._run_process(test, serial, adb_server_port=adb_server_port, adb_local_port=adb_local_port, script_args=script_args, media_path=media_path, apks=apks, timeout=timeout) # start the process result = self._parse_file_for_resolution(output, error) if result != Global.SUCCESS: self.upload_testlib_logs() return result, str(output) + " " + str(error)
def set_up(self): """ Initialize the test """ UseCaseBase.set_up(self) # Clear all data connections self._networking_api.clean_all_data_connections() time.sleep(self._wait_btwn_cmd) # Connect to equipment self._ns.init() # Set the equipment application format GSM/GPRS self._ns.switch_app_format("GSM/GPRS") # Perform a full preset self._ns.perform_full_preset() # Set cell off self._ns_cell_2g.set_cell_off() # Set serving cell to EGPRS self._ns_cell_2g.set_cell_service("EGPRS") # Set Frequency points using frequency list # Set Amplitude Offset correction using offset list # Turning amplitude offset state to ON self._ns.configure_amplitude_offset_table() # Set the equipment IP address 1 self._ns.set_ip4_lan_address(self._ns_IP_Lan1) # Set the equipment IP_Lan2 to the equipment self._ns.set_ip4_lan_address2(self._ns_IP_Lan2) # Set the equipment subnet mask self._ns.set_ip4_subnet_mask(self._ns_Subnet_Mask) # Set the equipment default gateway self._ns.set_ip4_default_gateway(self._ns_Default_Gateway) # Set the DUT IP address 1 self._ns_data_2g.set_dut_ip_address(1, self._ns_DUT_IP_Address) # Set the DUT DNS1 self._ns_data_2g.set_dut_primary_dns(self._ns_DNS1) # Set the DUT DNS2 self._ns_data_2g.set_dut_secondary_dns(self._ns_DNS2) # Set Cell Power using CELL_POWER parameter self._ns_cell_2g.set_cell_power(self._cell_power) # Set VOICE_CODER_RATE self._ns_voice_call_2g.set_audio_codec(self._voice_coder_rate) # Set connection type to auto self._ns_data_2g.set_connection_type("AUTO") # Set Cell Band using CELL_BAND parameter self._ns_cell_2g.set_band(self._band_name) # Set Broadcast Channel Arfcn using BCH_ARFCN parameter self._ns_cell_2g.set_bcch_arfcn(self._bch_arfcn) # Set PDTCH Arfcn using PDTCH_ARFCN parameter self._ns_cell_2g.set_pdtch_arfcn(self._pdtch_arfcn) # Set the multislot configuration self._ns_data_2g.set_multislot_config(self._multislot) # Set the downlink and uplink Modulation Coding Schema # (DL_MCS and UL_MCS) self._ns_data_2g.set_pdtch_modulation_coding_scheme( self._dl_mcs, self._ul_mcs) # Set the Puncturing Modulation Coding Schema (PS_MCS) self._ns_data_2g.set_pdtch_puncturing_scheme(self._ps_mcs) # Set DTM state to ON self._ns_cell_2g.set_dtm_state("ON") # Set cell on self._ns_cell_2g.set_cell_on() # Check Data Connection State => ATTACHED before timeout RegUtil.check_dut_data_connection_state_before_timeout("ATTACHED", self._ns_cell_2g, self._networking_api, self._logger, self._registration_timeout) # Check registration state is connected using # registrationTimeout from Device_Catalog.xml (Non blocking # for this test if function isn't implemented on CDK) self._modem_api.check_cdk_registration_bfor_timeout( self._registration_timeout) # Get RAT from Equipment network_type = self._ns_data_2g.get_network_type() # Check that DUT is registered on the good RAT self._modem_api.check_network_type_before_timeout(network_type, self._registration_timeout) # Set the APN time.sleep(self._wait_btwn_cmd) self._logger.info("Setting APN " + str(self._apn) + "...") self._networking_api.set_apn(self._ssid, self._apn) # Activate PDP context time.sleep(self._wait_btwn_cmd) self._logger.info("Active PDP Context...") self._networking_api.activate_pdp_context(self._ssid) # Check Data Connection State => PDP Active before timeout self._ns_data_2g.check_data_connection_state("PDP_ACTIVE", self._registration_timeout) # IF DIRECTION is UL starting upload FTP # Start ftp upload of "put100M" file using following parameters : # DIRECTION, IP, username, password if self._direction == "UL": self._ftp_direction = self._uecmd_types.XFER_DIRECTIONS.UL # pylint: disable=E1101 self._ftp_filename = self._ulfilename # ELIF DIRECTION is DL starting download FTP # Start ftp download of "get500M" file using following parameters : # DIRECTION, IP, username, password elif self._direction == "DL": self._ftp_direction = self._uecmd_types.XFER_DIRECTIONS.DL # pylint: disable=E1101 self._ftp_filename = self._dlfilename # ELSE raise an error # Raise an error in case the direction is not known else: self._logger.error("Unknown ftp direction (%s)" % self._direction) raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, "Unknown ftp direction.") return Global.SUCCESS, "No errors"