class LabAudioGlitchDetectionBase(UseCaseBase): """ AudioComms Audio CSV Call class. """ def __init__(self, tc_name, global_config): """ Constructor """ # Call UseCaseBase Init function UseCaseBase.__init__(self, tc_name, global_config) # Create Audio Analyzer instance 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 = "glitchdetection" # Initialization of test result self._result_verdict = Global.FAILURE # Initialization of the verdict comment self._verdict_comment = "Audio Glitch detection test fail" # Initialization of _dut_bt_address self._dut_bt_address = "None" # 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 type from test case xml file (str) self._acc_type = \ str(self._tc_parameters.get_param_value("ACC_TYPE")) # Call Stream Volume in percent self._call_stream_volume_dut = \ int(self._tc_parameters.get_param_value("CALL_VOLUME_DUT")) # Call Stream Volume in percent self._call_stream_volume_ref = \ int(self._tc_parameters.get_param_value("CALL_VOLUME_REF")) # 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 (str) 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._phonemodem_api = self._device.get_uecmd("Modem") self._system_api = self._device.get_uecmd("System") if self._acc_type.find("BLUETOOTH") != -1: # Get UECmdLayer self._bt_api = self._device.get_uecmd("LocalConnectivity") # Load instance of the PHONE2 self._phone2 = DeviceManager().get_device("PHONE2") # Instantiate system UECmd for Phone2 self._system_api2 = None 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_type.find("BLUETOOTH") != -1: # Get dut bt address self._dut_bt_address = self._bt_api.get_bt_adapter_address() def run_test(self): """ Execute the test """ # Call UseCaseBase run_test function UseCaseBase.run_test(self) # Connect Bluetooth device if self._acc_type.find("BLUETOOTH") != -1: 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 TestEquipmentException( TestEquipmentException.OPERATION_FAILED, error_msg) def tear_down(self): """ End and dispose the test """ # Call UseCaseBase tear_down function UseCaseBase.tear_down(self) # Reset Voice Call Volume at 70% if self._system_api is not None: self._system_api.adjust_specified_stream_volume("VoiceCall", 70) if self._system_api2 is not None: self._system_api2.adjust_specified_stream_volume("VoiceCall", 70) def __compute_test_verdict__(self, audio_analyzer_result): """ Compute the result verdict and the verdict comment :type audio_analyzer_result: int :param audio_analyzer_result: the audio analyzer return code return by run command """ if audio_analyzer_result == 0: self._result_verdict = Global.SUCCESS self._verdict_comment = ( "Audio Glitch detection test success: in %s with " "a %s call and %s accessories" % (self._signal_tested_direction, self._call_type, self._acc_type)) elif audio_analyzer_result == 1: self._result_verdict = Global.FAILURE self._verdict_comment = ( "Audio Glitch detection test fail: Audio Analyzer quality audio " "problems detected in %s with a %s call and " "%s accessories" % (self._signal_tested_direction, self._call_type, self._acc_type)) elif audio_analyzer_result == 2: self._result_verdict = Global.FAILURE self._verdict_comment = ( "Audio Glitch detection test fail: No audio signal in %s with " "a %s call and %s accessories" % (self._signal_tested_direction, self._call_type, self._acc_type)) else: self._result_verdict = Global.BLOCKED self._verdict_comment = ( "Audio Glitch detection test fail: Audio Analyzer problems detected " "in %s with a %s call and %s accessories" % (self._signal_tested_direction, self._call_type, self._acc_type))
class LabAudioActivityBase(UseCaseBase): """ AudioComms Audio CSV Call class. """ 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 test result self._result_verdict = Global.BLOCKED # Initialization of the verdict comment self._verdict_comment = "Audio Quality test fail" # Initialization of _dut_bt_address self._dut_bt_address = "None" # 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 type from test case xml file (str) self._acc_type = \ str(self._tc_parameters.get_param_value("ACC_TYPE")) # Call Stream Volume in percent self._call_stream_volume_dut = \ int(self._tc_parameters.get_param_value("CALL_VOLUME_DUT")) # Call Stream Volume in percent self._call_stream_volume_ref = \ int(self._tc_parameters.get_param_value("CALL_VOLUME_REF")) # 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 (str) 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") # Initialization of the test type if self._audio_analyzer_node.get_param_value("Model") in "APx585": self._test_type = "audioactivity" elif self._audio_analyzer_node.get_param_value("Model") in "RS_UPV": self._test_type = self._name else: error_msg = \ "Audio Analyzer model not supported or incorrect" self._logger.error(error_msg) raise AcsConfigException(AcsConfigException.INVALID_BENCH_CONFIG, error_msg) # Instantiate generic UECmd for voiceCall Ucs self._phonemodem_api = self._device.get_uecmd("Modem") self._networking_api = self._device.get_uecmd("Networking") self._system_api = self._device.get_uecmd("System") self._phonesystem_api = self._device.get_uecmd("PhoneSystem") self._voice_call_api = self._device.get_uecmd("VoiceCall") if self._acc_type.find("BLUETOOTH") != -1: # Get UECmdLayer self._bt_api = self._device.get_uecmd("LocalConnectivity") # Get BT device MAC address self._bt_remote_addr = self._audio_analyzer_node.get_param_value( "Bt_mac_addr") # Load instance of the PHONE2 self._phone2 = DeviceManager().get_device("PHONE2") # Instantiate system UECmd for Phone2 self._system_api2 = None # Time elapsed during voice call self._elapsed_time = 0 self._is_network_simulator_used = False # Time to wait between 2 successive measurement self._wait_between_measure = 0 if "NETWORK_SIMULATOR1" in global_config.benchConfig.get_parameters_name( ): self._is_network_simulator_used = True # 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") self._ns_node = global_config.benchConfig.get_parameters( "NETWORK_SIMULATOR1") self._ns = self._em.get_cellular_network_simulator( "NETWORK_SIMULATOR1") if "2G" in self._call_type: self._ns_cell = self._ns.get_cell_2g() elif "3G" in self._call_type: self._ns_cell = self._ns.get_cell_3g() elif "4G" in self._call_type: self._ns_cell = self._ns.get_cell_4g() else: msg = "Wrong value for parameter CALL_TYPE (Must be one of the following: 2G, 3G, 4G)" self._logger.error(msg) raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg) self._analog_input_peak_level = self._ns_node.get_param_value( "AnalogInputPeakLevel") self._analog_output_peak_level = self._ns_node.get_param_value( "AnalogOutputPeakLevel") self._vc = self._ns_cell.get_voice_call() # Read call parameters from test case xml file self._cell_band = \ int(self._tc_parameters.get_param_value("CELL_BAND", 1)) self._codec = str(self._tc_parameters.get_param_value("CODEC")) # In case of long lasting call, update the waiting time between measurements if self._call_duration > 60: # Read time between 2 successive measurement self._wait_between_measure = int( self._tc_parameters.get_param_value( "WAIT_BETWEEN_MEASURE")) 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") # 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_type.find("BLUETOOTH") != -1: # Get dut bt address self._dut_bt_address = self._bt_api.get_bt_adapter_address() if self._is_network_simulator_used: # Perform network configuration # Connect to equipment self._ns.init() # Perform a full preset self._ns.perform_full_preset() # Flight mode activation self._networking_api.set_flight_mode("on") # Set cell off self._ns_cell.set_cell_off() if self._call_type in "2G" or self._call_type in "3G": # 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) elif self._call_type in "4G": self._logger.info("Setting APN for IMS " + str(self._apn) + " on protocol IPV4 ") # APN for AP centric self._networking_api.set_apn(self._ssid, self._apn, None, None, "IP", None, "default") # APN for BP centric self._networking_api.set_apn("ims", "ims", None, None, "IP", None, "ims", False, False) # Load cell configuration self._ns.load_cell_config("COMMON_LTE") self._ns.load_cell_config(self._cell_band) # Load IMS server configuration self._ns.load_cell_config("COMMON_IMS") self._ns_cell.set_ims_on() time.sleep(10) else: msg = "Wrong value for parameter CALL_TYPE (Must be one of the following: 2G, 3G, 4G)" self._logger.error(msg) raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg) # Perform audio configuration self._vc.set_audio_codec(self._codec) self._vc.set_speech_configuration("AUDioboard") self._vc.calibrate_analog_audio_level( self._analog_input_peak_level, self._analog_output_peak_level) if self._call_type in "4G": # Set DAU on self._ns_cell.get_data().set_epc_on() self._ns_cell.set_ims_on() # Set Cell on self._ns_cell.set_cell_on() # Phone has to see the cell off! self._phonemodem_api.check_cdk_no_registration_bfor_timeout( self._registration_timeout) # Flight mode deactivation self._networking_api.set_flight_mode("off") time.sleep(self._wait_btwn_cmd) # Check registration state is connected using # registrationTimeout from Device_Catalog.xml self._logger.info("Check registration state is connected") self._phonemodem_api.check_cdk_registration_bfor_timeout( self._registration_timeout) if self._call_type in "4G": # Check IMS connection state self._ns_cell.get_data().check_ims_connection_state( "REG", self._registration_timeout) time.sleep(self._wait_btwn_cmd) else: # 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) # Connect Bluetooth device if self._acc_type.find("BLUETOOTH") != -1: 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) def tear_down(self): """ End and dispose the test """ # Call UseCaseBase tear_down function UseCaseBase.tear_down(self) # Reset Voice Call Volume at 70% if self._system_api is not None: self._system_api.adjust_specified_stream_volume("VoiceCall", 70) if self._system_api2 is not None: self._system_api2.adjust_specified_stream_volume("VoiceCall", 70) def __compute_test_verdict__(self, apx_result): """ Compute the result verdict and the verdict comment :type apx_result: int :param apx_result: the apx585 return code return by run command """ if (apx_result == 0): self._result_verdict = Global.SUCCESS self._verdict_comment = ("Audio Quality test success: in %s with " "a %s call and %s accessories" % (self._signal_tested_direction, self._call_type, self._acc_type)) elif (apx_result == 1): self._result_verdict = Global.FAILURE self._verdict_comment = ( "Audio Quality test fail: APx585 quality audio " "problems detected in %s with a %s call and " "%s accessories" % (self._signal_tested_direction, self._call_type, self._acc_type)) elif (apx_result == 2): self._result_verdict = Global.FAILURE self._verdict_comment = ( "Audio Quality test fail: No audio signal in %s with " "a %s call and %s accessories" % (self._signal_tested_direction, self._call_type, self._acc_type)) elif (apx_result == 3): self._result_verdict = Global.BLOCKED self._verdict_comment = ( "Audio Quality test fail: Apx585 executable exception occurred" ) else: self._result_verdict = Global.BLOCKED self._verdict_comment = ( "Audio Quality test fail: APx585 problems detected " "in %s with a %s call and %s accessories" % (self._signal_tested_direction, self._call_type, self._acc_type)) def _get_elapsed_time(self, time_stamp_start, time_stamp_current): """ Get elapsed time between 2 time stamps :type time_stamp_start: time.struct_time :param time_stamp_start: reference time stamp :type time_stamp_current: time.struct_time :param time_stamp_current: current time stamp """ elapsed_time = [ 3600 * 24 * 12 * 365, 3600 * 24 * 12, 3600 * 24, 3600, 60, 1 ] for i in range(len(time_stamp_start) - 3): elapsed_time[i] *= time_stamp_current[i] - time_stamp_start[i] return sum(elapsed_time)
class LabAudioGlitchDetectionSwapCall(UseCaseBase): """ AudioComms Audio Swap Call class. """ def __compute_test_verdict__(self, audio_analyzer_result): if audio_analyzer_result == 0 and self._audio_analyzer_result_save == 0: self._result_verdict = Global.SUCCESS elif audio_analyzer_result == 1: # Update audio_analyser_result => error code 1 lower priority than error code 2 if self._audio_analyzer_result_save == 0 or self._audio_analyzer_result_save == 3: self._audio_analyzer_result_save = 1 # Save failed transition self._failed_transition_audio_pb = self._failed_transition_audio_pb + ", " + \ self._previous_call_type_save + " => " + self._call_type_save self._result_verdict = Global.FAILURE elif audio_analyzer_result == 2: self._audio_analyzer_result_save = 2 self._failed_transition_no_audio = self._failed_transition_no_audio + ", " + \ self._previous_call_type_save + " => " + self._call_type_save self._result_verdict = Global.FAILURE elif audio_analyzer_result == 3: self._audio_analyzer_result_save = 3 self._result_verdict = Global.FAILURE self._failed_transition_no_audio = self._failed_transition_no_audio + ", " + \ self._previous_call_type_save + " => " + self._call_type_save else: if self._audio_analyzer_result_save == 0: self._audio_analyzer_result_save = 4 self._result_verdict = Global.FAILURE def __init__(self, tc_name, global_config): """ Constructor """ # Call UseCaseBase Init function UseCaseBase.__init__(self, tc_name, global_config) # Create Audio Analyser 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 = "glitchdetectiononswap" # Initialization of test result self._result_verdict = Global.FAILURE # Initialization of the verdict comment self._verdict_comment = "Audio Quality test fail" # Initialization of _dut_bt_address self._dut_bt_address = "None" # Initialization of audio_analyser_result saved self._audio_analyzer_result_save = 0 self._audio_analyzer_result_ul = 0 self._audio_analyzer_result_dl = 0 # delta volume for voip self._delta_voip_volume = 10 # Initialization of failed transition saved self._failed_transition_audio_pb = "" self._failed_transition_no_audio = "" self._previous_call_type_save = "" self._call_type_save = "" self._phone_calling_list = [] self._phone_receiving_list = [] self._phone_releasing_list = [] self._ui_api_phone_list = [] self._calling_phone_number = [] # List Saving self._saved_call_list = [] self._saved_call_end_type_list = [] self._saved_call_origin_type_list = [] self._call_type_list_audio_analyser_run = [] # Instantiate the instances for phone caller, receiver and releaser self._phone_calling = None self._phone_receiving = None # 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 wifi parameters from bench config xml file (int) self._wifirouter = global_config.benchConfig.\ get_parameters("WIFI_ACCESS_POINT") self._ssid = self._wifirouter.get_param_value("SSID") # Read accessories type from test case xml file (str) self._acc_type = \ str(self._tc_parameters.get_param_value("ACC_TYPE")) # Read call type list from test case xml file (str) self._call_seq = str( self._tc_parameters.get_param_value("CALL_SEQUENCE")) # Split the call type list, call separated by ',' self._call_seq = self._call_seq.strip('[] ') self._call_list = self._call_seq.split(',') self._call_list.reverse() # Read call origin list from test case xml file (str) self._call_origin_type = \ str(self._tc_parameters.get_param_value("CALL_ORIGIN_TYPE_SEQUENCE")) # Split the call origin type list, call origin type separated by ',' self._call_origin_type = self._call_origin_type.strip('[] ') self._call_origin_type_list = self._call_origin_type.split(',') self._call_origin_type_list.reverse() # Read call end type list from test case xml file (str) self._call_end_type = \ str(self._tc_parameters.get_param_value("CALL_END_TYPE_SEQUENCE")) # Split the call end type list, call end type separated by ',' self._call_end_type = self._call_end_type.strip('[] ') self._call_end_type_list = self._call_end_type.split(',') self._call_end_type_list.reverse() # Read call type from test case xml file (str) self._call_type = str(self._tc_parameters.get_param_value("CALL_TYPE")) # Call Stream Volume in percent self._call_stream_volume_dut = \ int(self._tc_parameters.get_param_value("CALL_VOLUME_DUT")) # Call Stream Volume in percent self._call_stream_volume_ref = \ int(self._tc_parameters.get_param_value("CALL_VOLUME_REF")) # 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 number of swap from test case xml file (int) self._number_of_swap = int( self._tc_parameters.get_param_value("SWAP_REPETITION")) # Read dut sip address from test case xml file (str) self._dut_sip_address = \ str(self._tc_parameters.get_param_value("DUT_SIP_ADDRESS")) # Read ref phone sip address from test case xml file (str) self._peer_sip_address = \ str(self._tc_parameters.get_param_value("PEER_SIP_ADDRESS")) # Read dut sip profile name from test case xml file (str) self._dut_sip_profile = \ str(self._tc_parameters.get_param_value("DUT_SIP_PROFILE")) # Read ref phone sip profile name from test case xml file (str) self._peer_sip_profile = \ str(self._tc_parameters.get_param_value("PEER_SIP_PROFILE")) # Read test call direction type from test case xml file (str) self._signal_tested_direction = \ str(self._tc_parameters.get_param_value("SIGNAL_TESTED_DIRECTION")) # Read Audio Analyzer parameters from bench config xml file (str) self._audio_analyser = global_config.benchConfig.\ get_parameters("AudioAnalyzer") self._bt_remote_addr = self._audio_analyser.get_param_value( "Bt_mac_addr") # Instantiate generic UECmd for voiceCall Ucs self._voice_call_api = self._device.get_uecmd("VoiceCall") self._phonesystem_api = self._device.get_uecmd("PhoneSystem") self._sip_call_api = self._device.get_uecmd("SipCall") self._phonemodem_api = self._device.get_uecmd("Modem") self._system_api = self._device.get_uecmd("System") self._networking_api = self._device.get_uecmd("Networking") self._ui_api = self._device.get_uecmd("Ui") self._ui_api.set_global_config(global_config) # Read Audio Analyzer parameters from bench config xml file (str) self._audio_analyser = global_config.benchConfig.get_parameters( "AudioAnalyzer") if self._acc_type.find("BLUETOOTH") != -1: # Get UECmdLayer self._bt_api = self._device.get_uecmd("LocalConnectivity") self._bt_remote_addr = self._audio_analyser.get_param_value( "Bt_mac_addr") # Load instance of the PHONE2 self._phone2 = DeviceManager().get_device("PHONE2") # Instantiate system UECmd for Phone2 self._system_api2 = None # Initialize UI object self._ui_api.init() # Connect the board self._device.connect_board() if self._phone2 is not None: if not self._phone2.is_available(): self._phone2.switch_on(simple_switch_mode=True) self._voice_call_api2 = self._phone2.get_uecmd("VoiceCall") self._sip_call_api2 = self._phone2.get_uecmd("SipCall") self._ui_api2 = self._phone2.get_uecmd("Ui") self._ui_api2.set_global_config(global_config) self._system_api2 = self._phone2.get_uecmd("System") self._networking_api2 = self._phone2.get_uecmd("Networking") self._phonesystem_api2 = self._phone2.get_uecmd("PhoneSystem") self._ui_api2.init() else: error_msg = \ "This test case requires two phones to be executed !" self._logger.error(error_msg) raise AcsConfigException(AcsConfigException.INVALID_BENCH_CONFIG, error_msg) 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 None: # 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) self._phonesystem_api.wake_screen() # 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) # List Saving self._saved_call_list = list(self._call_list) self._saved_call_end_type_list = list(self._call_end_type_list) self._saved_call_origin_type_list = list(self._call_origin_type_list) # make list for call test type for audio_analyser l_temp_call_list = list(self._call_list) l_temp_call_list.reverse() self._call_type_list_audio_analyser_run = list(l_temp_call_list) num_of_swap_unpair = self._number_of_swap % 2 i = self._number_of_swap while i > 1: self._call_type_list_audio_analyser_run += list(l_temp_call_list) i -= 1 if num_of_swap_unpair > 0: # Grep last element of call list and insert at the top self._call_type_list_audio_analyser_run.insert( 0, l_temp_call_list.pop()) i = 1 # Initialization of list for calling, receiving and releasing calls while len(self._saved_call_list) > 0: call_type = self._saved_call_list.pop() call_origin = self._saved_call_origin_type_list.pop() call_end = self._saved_call_end_type_list.pop() if call_origin == "MO": self._phone_calling_list.insert(i, self._voice_call_api) self._phone_receiving_list.insert(i, self._voice_call_api2) self._ui_api_phone_list.insert(i, self._ui_api2) if call_type == "2G" or call_type == "3G": self._calling_phone_number.insert( i, self._phone2.get_phone_number()) elif call_type == "VOIP": self._calling_phone_number.insert(i, self._peer_sip_address) else: error_msg = "This test case requires call type to be executed !" self._logger.error(error_msg) raise AcsConfigException( AcsConfigException.INVALID_PARAMETER, error_msg) elif call_origin == "MT": self._phone_calling_list.insert(i, self._voice_call_api2) self._phone_receiving_list.insert(i, self._voice_call_api) self._ui_api_phone_list.insert(i, self._ui_api) if call_type == "2G" or call_type == "3G": self._calling_phone_number.insert( i, self._device.get_phone_number()) elif call_type == "VOIP": self._calling_phone_number.insert(i, self._dut_sip_address) else: error_msg = "This test case requires call type to be executed !" self._logger.error(error_msg) raise AcsConfigException( AcsConfigException.INVALID_PARAMETER, error_msg) else: error_msg = \ "This test case requires call originated type to be executed !" self._logger.error(error_msg) raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, error_msg) if call_end == "NR": self._phone_releasing_list.insert(i, self._voice_call_api2) elif call_end == "MR": self._phone_releasing_list.insert(i, self._voice_call_api) else: error_msg = \ "This test case requires call end type to be executed !" self._logger.error(error_msg) raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, error_msg) i += 1 self._activate_wifi = False while len(self._saved_call_list) > 0: call_type = self._saved_call_list.pop() if call_type == "VOIP": self._activate_wifi = True if self._activate_wifi == True: if self._networking_api.get_wifi_power_status() == 0: # Turn Wifi interface ON self._networking_api.set_wifi_power("off") self._networking_api.set_wifi_power("on") # Configure the DUT self._networking_api.clean_all_data_connections() time.sleep(self._wait_btwn_cmd) # Connect to wifi using SSID parameter value for DUT self._networking_api.wifi_connect(self._ssid) time.sleep(self._wait_btwn_cmd) if self._networking_api2.get_wifi_power_status() == 0: self._networking_api2.set_wifi_power("off") self._networking_api2.set_wifi_power("on") self._networking_api2.clean_all_data_connections() time.sleep(self._wait_btwn_cmd) # Connect to wifi using SSID parameter value for Ref phone self._networking_api2.wifi_connect(self._ssid) time.sleep(self._wait_btwn_cmd) self._phonesystem_api.set_screen_timeout(900) self._phonesystem_api2.set_screen_timeout(900) # Audio Analyser Initialization if self._audio_analyzer.initialization(self._device.get_phone_model(), self._test_type) != 0: error_msg = "Audio Analyser Initialization Failed !" self._logger.error(error_msg) raise TestEquipmentException( TestEquipmentException.OPERATION_FAILED, error_msg) if self._acc_type.find("BLUETOOTH") != -1: self._dut_bt_address = self._bt_api.get_bt_adapter_address() self._sip_call_api.set_profile_sip_phone_app(self._dut_sip_profile) self._sip_call_api2.set_profile_sip_phone_app(self._peer_sip_profile) self._phone_calling_list.reverse() self._phone_receiving_list.reverse() self._phone_releasing_list.reverse() # self._calling_phone_number_list.reverse() self._ui_api_phone_list.reverse() self._calling_phone_number.reverse() # Release any previous call (Robustness) self._voice_call_api.release() self._voice_call_api2.release() return Global.SUCCESS, "No errors" def run_test(self): """ Execute the test """ # Call UseCaseBase run_test function UseCaseBase.run_test(self) if self._acc_type == "HEADSET": if self._use_io_card: self._wired_headset.unplug_headphone() self._wired_headset.plug_whs() elif self._acc_type == "HEADPHONE": if self._use_io_card: self._wired_headset.unplug_whs() self._wired_headset.plug_headphone() # Connect Bluetooth device if self._acc_type.find("BLUETOOTH") != -1: 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) self._phonesystem_api.display_off() self._phonesystem_api2.display_off() self._phonesystem_api.display_on() self._phonesystem_api2.display_on() # Unlock phones self._ui_api2.run_operation_set("phone_unlock") self._ui_api.run_operation_set("phone_unlock") l_audio_analyzer_result = 3 l_call_type = self._call_list.pop() l_phone_calling = self._phone_calling_list.pop() l_phone_receiving = self._phone_receiving_list.pop() l_phone_ui = self._ui_api_phone_list.pop() self._call_type_save = l_call_type # Dial using PHONE_NUMBER parameter l_phone_calling.dial(self._calling_phone_number.pop(), False) time.sleep(self._wait_btwn_cmd) if l_call_type == "2G" or l_call_type == "3G": # Wait for state "active" before callSetupTimeout seconds l_phone_receiving.wait_for_state( self._uecmd_types.VOICE_CALL_STATE.INCOMING, self._call_setup_time) # Answer call l_phone_receiving.answer() # Phone1 & 2 : Check voice call is active l_phone_calling.wait_for_state( self._uecmd_types.VOICE_CALL_STATE.ACTIVE, self._call_setup_time) l_phone_receiving.wait_for_state( self._uecmd_types.VOICE_CALL_STATE.ACTIVE, self._call_setup_time) elif l_call_type == "VOIP": # Wait for state "active" before callSetupTimeout seconds l_phone_receiving.wait_for_audio_state( self._uecmd_types.AUDIO_STATE.RINGTONE, self._call_setup_time) # Answer call l_phone_ui.run_operation_set("call_answer") # Phone1 & 2 : Check voice call is active l_phone_calling.wait_for_audio_state( self._uecmd_types.AUDIO_STATE.IN_COMMUNICATION, self._call_setup_time) l_phone_receiving.wait_for_audio_state( self._uecmd_types.AUDIO_STATE.IN_COMMUNICATION, self._call_setup_time) # Configure Audio output to acc_type given with the test_case if self._acc_type == "EARPIECE": if self._use_io_card: self._wired_headset.unplug_headphone() self._wired_headset.unplug_whs() elif self._acc_type == "SPEAKER": # Switch to Speaker, nothing to do in Earpiece # Bluetooth already done with connect Bluetooth function above self._phonesystem_api.switch_audio_output(self._acc_type.lower()) time.sleep(self._wait_btwn_cmd) # Voice call volume settings if self._acc_type.find("BLUETOOTH") == -1: # Set Voice Call Volume self._system_api.adjust_specified_stream_volume( "VoiceCall", self._call_stream_volume_dut) else: # Set Voice Call Volume self._system_api.adjust_specified_stream_volume( "Bluetooth", self._call_stream_volume_dut) self._system_api2.adjust_specified_stream_volume( "VoiceCall", self._call_stream_volume_ref) # WAIT FOR CALL DURATION self._logger.info("Wait for call duration: %s s..." % str(self._call_duration)) l_call_type = self._call_list.pop() l_phone_calling = self._phone_calling_list.pop() l_phone_receiving = self._phone_receiving_list.pop() l_phone_ui = self._ui_api_phone_list.pop() self._previous_call_type_save = self._call_type_save self._call_type_save = l_call_type # Dial using PHONE_NUMBER parameter l_phone_calling.dial(self._calling_phone_number.pop(), False) time.sleep(self._wait_btwn_cmd) if l_call_type == "2G" or l_call_type == "3G": # Wait for state "active" before callSetupTimeout seconds l_phone_receiving.wait_for_state( self._uecmd_types.VOICE_CALL_STATE.INCOMING, self._call_setup_time) # Answer call l_phone_receiving.answer() # Phone1 & 2 : Check voice call is active l_phone_calling.wait_for_state( self._uecmd_types.VOICE_CALL_STATE.ACTIVE, self._call_setup_time) l_phone_receiving.wait_for_state( self._uecmd_types.VOICE_CALL_STATE.ACTIVE, self._call_setup_time) else: # Answer call time.sleep(5) l_phone_ui.run_operation_set("call_answer") # Phone1 & 2 : Check voice call is active l_phone_calling.wait_for_audio_state( self._uecmd_types.AUDIO_STATE.IN_COMMUNICATION, self._call_setup_time) l_phone_receiving.wait_for_audio_state( self._uecmd_types.AUDIO_STATE.IN_COMMUNICATION, self._call_setup_time) self._call_type_list_audio_analyser_run.pop() while self._number_of_swap > 0: self._phonesystem_api2.wake_screen() time.sleep(self._wait_btwn_cmd) self._ui_api2.run_operation_set("swap_call") call_type_audio_analyzer = self._call_type_list_audio_analyser_run.pop( ) if call_type_audio_analyzer == "VOIP": self._system_api2.adjust_specified_stream_volume( "VoiceCall", (self._call_stream_volume_ref + self._delta_voip_volume)) else: self._system_api2.adjust_specified_stream_volume( "VoiceCall", self._call_stream_volume_ref) self._phonesystem_api.wake_screen() time.sleep(self._wait_btwn_cmd) # Launch audio_quality test l_audio_analyzer_ready, l_audio_analyzer_process = self._audio_analyzer.glitch_detection_before_switch( self._test_type, self._device.get_phone_model(), call_type_audio_analyzer, self._acc_type, self._signal_tested_direction) if l_audio_analyzer_ready == 0: self._ui_api.run_operation_set("swap_call") l_audio_analyzer_result = self._audio_analyzer.glitch_detection_after_switch( l_audio_analyzer_process) # Compute test verdict self.__compute_test_verdict__(l_audio_analyzer_result) self._previous_call_type_save = self._call_type_save self._call_type_save = call_type_audio_analyzer self._number_of_swap -= 1 l_phone_releasing = self._phone_releasing_list.pop() # Hang up call l_phone_releasing.release(False) time.sleep(self._wait_btwn_cmd) l_phone_releasing = self._phone_releasing_list.pop() # Hang up call l_phone_releasing.release() # Phone1 & 2 : Check call is idle l_phone_calling.wait_for_state( self._uecmd_types.VOICE_CALL_STATE.NOCALL, self._call_setup_time) l_phone_receiving.wait_for_state( self._uecmd_types.VOICE_CALL_STATE.NOCALL, self._call_setup_time) if self._audio_analyzer_result_save == 0: self._verdict_comment = ( "Audio Glitch detection test success with %s call sequence" % (str(self._tc_parameters.get_param_value("CALL_SEQUENCE")))) elif self._audio_analyzer_result_save == 1: self._verdict_comment = ( "Audio Glitch detection test fail: Glitch " "problems detected in %s with " "%s call sequence" % (self._signal_tested_direction, self._failed_transition_audio_pb)) elif self._audio_analyzer_result_save == 2: self._verdict_comment = ( "Audio Glitch detection test fail: No audio signal in %s with " "%s call sequence" % (self._signal_tested_direction, self._failed_transition_no_audio)) elif self._audio_analyzer_result_save == 3: self._verdict_comment = ( "Audio Glitch detection test fail: Exception in executable " "in %s with %s call sequence" % (self._signal_tested_direction, self._failed_transition_no_audio)) else: self._verdict_comment = ( "Audio Glitch detection test fail: Unknown problems detected " "with a %s call sequence" % (str(self._tc_parameters.get_param_value("CALL_SEQUENCE")))) return self._result_verdict, self._verdict_comment def tear_down(self): """ End and dispose the test """ # Call UseCaseBase tear_down function UseCaseBase.tear_down(self) if self._acc_type == "HEADSET": if self._use_io_card: self._wired_headset.unplug_whs() elif self._acc_type == "HEADPHONE": if self._use_io_card: self._wired_headset.unplug_headphone() # Release any previous call (Robustness) if self._voice_call_api is not None: self._voice_call_api.release(False) if self._voice_call_api2 is not None: self._voice_call_api2.release(False) self._sip_call_api.delete_profile_sip_phone_app() self._sip_call_api2.delete_profile_sip_phone_app() # Reset Voice Call Volume at 70% if self._system_api is not None: self._system_api.adjust_specified_stream_volume("VoiceCall", 70) if self._system_api2 is not None: self._system_api2.adjust_specified_stream_volume("VoiceCall", 70) # Disable Wifi connections if self._result_verdict != Global.SUCCESS: if self._networking_api is not None: self._networking_api.clean_all_data_connections() time.sleep(self._wait_btwn_cmd) self._networking_api.set_wifi_power("off") if self._networking_api2 is not None: self._networking_api2.clean_all_data_connections() time.sleep(self._wait_btwn_cmd) self._networking_api2.set_wifi_power("off") return Global.SUCCESS, "No errors"
class LabAudioAPxCalibrationVOIP(UseCaseBase): """ AudioComms calibration APx class. """ def __init__(self, tc_name, global_config): """ Constructor """ # Call UseCaseBase Init function UseCaseBase.__init__(self, tc_name, global_config) # Create APx 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 = "calibration" # Initialization of test result in uplink self._result_verdict_ul = Global.FAILURE # Initialization of test result in downlink self._result_verdict_dl = Global.FAILURE # Initialization of test result self._result_verdict_final = Global.FAILURE # Call Stream Volume self._call_stream_volume = 70 # Initialization of the verdict comment self._verdict_comment = "APx Calibration 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 accessories type from test case xml file (str) self._acc_type = str(self._tc_parameters.get_param_value("ACC_TYPE")) # Call Stream Volume in percent self._call_stream_volume_dut = \ int(self._tc_parameters.get_param_value("CALL_VOLUME_DUT")) # Call Stream Volume in percent self._call_stream_volume_ref = \ int(self._tc_parameters.get_param_value("CALL_VOLUME_REF")) # Read Audio Analyzer parameters from bench config xml file (str) self._audio_analyser = global_config.benchConfig.\ get_parameters("AudioAnalyzer") self._bt_remote_addr = self._audio_analyser.get_param_value( "Bt_mac_addr") # Read dut sip address from test case xml file (str) self._dut_sip_address = \ str(self._tc_parameters.get_param_value("DUT_SIP_ADDRESS")) # Read ref phone sip address from test case xml file (str) self._peer_sip_address = \ str(self._tc_parameters.get_param_value("PEER_SIP_ADDRESS")) # Instantiate generic UECmd for voiceCall Ucs self._networking_api = self._device.get_uecmd("Networking") self._sip_call_api = self._device.get_uecmd("SipCall") self._phonesystem_api = self._device.get_uecmd("PhoneSystem") self._system_api = self._device.get_uecmd("System") if self._acc_type.find("BLUETOOTH") != -1: # Get UECmdLayer self._bt_api = self._device.get_uecmd("LocalConnectivity") # Get dut bt address self._dut_bt_address = self._bt_api.get_bt_adapter_address() else: self._dut_bt_address = "None" # Load instance of the PHONE2 self._phone2 = DeviceManager().get_device("PHONE2") if self._phone2 is not None: if not self._phone2.is_available(): self._phone2.switch_on(simple_switch_mode=True) self._voice_call_api2 = self._phone2.get_uecmd("VoiceCall") self._system_api2 = self._phone2.get_uecmd("System") # Instantiate the instances of member class variables self._sip_call_api2 = None self._networking_api2 = None self._phone_calling = None self._phone_receiving = None self._phone_releasing = None self._calling_phone_number = None def set_up(self): """ Set up the test configuration """ # Call UseCaseBase Setup function UseCaseBase.set_up(self) if self._phone2 is not None: self._networking_api2 = self._phone2.get_uecmd("Networking") self._sip_call_api2 = self._phone2.get_uecmd("SipCall") else: error_msg = \ "This test case requires two phones to be executed !" self._logger.error(error_msg) raise AcsConfigException(AcsConfigException.INVALID_BENCH_CONFIG, error_msg) # APx Initialization if self._audio_analyzer.initialization(self._device.get_phone_model(), self._test_type) != 0: error_msg = \ "APX Initialization Failed !" self._logger.error(error_msg) raise TestEquipmentException( TestEquipmentException.OPERATION_FAILED, error_msg) # Setup phone type ( calling, receiving, releasing phone) self._phone_calling = self._sip_call_api self._phone_receiving = self._sip_call_api2 self._calling_phone_number = self._peer_sip_address self._phone_releasing = self._sip_call_api2 # Start Sip Service self._phone_calling.initialize_sipcall_module() self._phone_receiving.initialize_sipcall_module() # Setup Sip Account self._sip_call_api.initialize_local_profile(self._dut_sip_address) self._sip_call_api2.initialize_local_profile(self._peer_sip_address) return Global.SUCCESS, "No errors" def run_test(self): """ Execute the test """ # Call UseCaseBase run_test function UseCaseBase.run_test(self) self._phone_calling.wait_for_state( self._uecmd_types.SIP_CALL_STATE.READY_TO_CALL, self._call_setup_time) self._phone_receiving.wait_for_state( self._uecmd_types.SIP_CALL_STATE.READY_TO_CALL, self._call_setup_time) # Dial using PHONE_NUMBER parameter self._phone_calling.dial(self._calling_phone_number) self._phone_receiving.wait_for_state( self._uecmd_types.SIP_CALL_STATE.INCOMING_CALL, self._call_setup_time) self._phone_receiving.answer() # Phone1 & 2 : Check voice call is active self._phone_calling.wait_for_state( self._uecmd_types.SIP_CALL_STATE.IN_CALL, self._call_setup_time) self._phone_receiving.wait_for_state( self._uecmd_types.SIP_CALL_STATE.IN_CALL, self._call_setup_time) # Configure Audio output to acc_type given with the test_case except in Bluetooth test case if self._acc_type.find("BLUETOOTH") != -1: 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) # Configure Audio output to acc_type given with the test_case if self._acc_type == "EARPIECE": self._sip_call_api.switch_to_earpiece() if self._use_io_card: self._wired_headset.unplug_whs() self._wired_headset.unplug_headphone() time.sleep(self._wait_btwn_cmd) elif self._acc_type == "HEADSET": self._sip_call_api.switch_to_earpiece() if self._use_io_card: self._wired_headset.unplug_headphone() self._wired_headset.plug_whs() time.sleep(self._wait_btwn_cmd) elif self._acc_type == "HEADPHONE": self._sip_call_api.switch_to_earpiece() if self._use_io_card: self._wired_headset.unplug_whs() self._wired_headset.plug_headphone() time.sleep(self._wait_btwn_cmd) elif self._acc_type == "SPEAKER": self._sip_call_api.switch_to_speaker() time.sleep(self._wait_btwn_cmd) elif self._acc_type == "BLUETOOTHHSP" or self._acc_type == "BLUETOOTHHFP": self._sip_call_api.switch_to_bluetooth() elif self._acc_type == "BLUETOOTHA2DP": self._sip_call_api.switch_to_bluetooth() else: self._logger.error("Unknown accessories") raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, "Unknown accessories") time.sleep(self._wait_btwn_cmd) if self._acc_type.find("BLUETOOTH") == -1: # Set Voice Call Volume self._system_api.adjust_specified_stream_volume( "VoiceCall", self._call_stream_volume_dut) else: # Set Voice Call Volume self._system_api.adjust_specified_stream_volume( "Bluetooth", self._call_stream_volume_dut) self._system_api2.adjust_specified_stream_volume( "VoiceCall", self._call_stream_volume_ref) # Launch Apx Calibration test on Uplink apx_result = self._audio_analyzer.calibration( self._device.get_phone_model(), "VOIP", self._acc_type, "UL", self._dut_bt_address) if apx_result == 0: self._result_verdict_ul = Global.SUCCESS self._verdict_comment = "APx Calibration success in UL" else: self._result_verdict_ul = Global.FAILURE self._verdict_comment = "APx Calibration fail in UL" # Launch Apx Calibration test on Downlink apx_result = self._audio_analyzer.calibration( self._device.get_phone_model(), "VOIP", self._acc_type, "DL", self._dut_bt_address) if apx_result == 0: self._result_verdict_dl = Global.SUCCESS self._verdict_comment += " and APx Calibration success in DL" else: self._result_verdict_dl = Global.FAILURE self._verdict_comment += " and APx Calibration fail in DL" # Compute final verdict if self._result_verdict_ul == Global.FAILURE or \ self._result_verdict_dl == Global.FAILURE: self._result_verdict_final = Global.FAILURE else: self._result_verdict_final = Global.SUCCESS # RELEASE THE CALL # Phone1 & 2 : Check call is still active self._phone_calling.wait_for_state( self._uecmd_types.SIP_CALL_STATE.IN_CALL, self._call_setup_time) self._phone_receiving.wait_for_state( self._uecmd_types.SIP_CALL_STATE.IN_CALL, self._call_setup_time) self._phone_releasing.release() self._phone_releasing.wait_for_state( self._uecmd_types.SIP_CALL_STATE.READY_TO_CALL, self._call_setup_time) self._phone_receiving.wait_for_state( self._uecmd_types.SIP_CALL_STATE.READY_TO_CALL, self._call_setup_time) return self._result_verdict_final, self._verdict_comment def tear_down(self): """ End and dispose the test """ # Call LabAudioQualityBase run_test function UseCaseBase.tear_down(self) if self._acc_type == "HEADSET": if self._use_io_card: self._wired_headset.unplug_whs() elif self._acc_type == "HEADPHONE": if self._use_io_card: self._wired_headset.unplug_headphone() # Stop Sip Service if self._sip_call_api is not None: self._sip_call_api.clean_sipcall_module() if self._sip_call_api2 is not None: self._sip_call_api2.clean_sipcall_module() return Global.SUCCESS, "No errors"
class LabAudioAPxCalibrationCSV(UseCaseBase): """ AudioComms calibration APx class. """ def __init__(self, tc_name, global_config): """ Constructor """ # Call UseCaseBase Init function UseCaseBase.__init__(self, tc_name, global_config) # Create APx 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 = "calibration" # Initialization of test result in uplink self._result_verdict_ul = Global.FAILURE # Initialization of test result in downlink self._result_verdict_dl = Global.FAILURE # Initialization of test result self._result_verdict_final = Global.FAILURE # Call Stream Volume self._call_stream_volume = 70 # Initialization of the verdict comment self._verdict_comment = "APx Calibration 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 accessories type from test case xml file (str) self._acc_type = str(self._tc_parameters.get_param_value("ACC_TYPE")) # Call Stream Volume in percent self._call_stream_volume_dut = \ int(self._tc_parameters.get_param_value("CALL_VOLUME_DUT")) # Call Stream Volume in percent self._call_stream_volume_ref = \ int(self._tc_parameters.get_param_value("CALL_VOLUME_REF")) # Read Audio Analyzer parameters from bench config xml file (str) self._audio_analyser = global_config.benchConfig.\ get_parameters("AudioAnalyzer") self._bt_remote_addr = self._audio_analyser.get_param_value( "Bt_mac_addr") # Instantiate generic UECmd for voiceCall Ucs self._voice_call_api = self._device.get_uecmd("VoiceCall") self._phonesystem_api = self._device.get_uecmd("PhoneSystem") self._phonemodem_api = self._device.get_uecmd("Modem") self._system_api = self._device.get_uecmd("System") if self._acc_type.find("BLUETOOTH") != -1: # Get UECmdLayer self._bt_api = self._device.get_uecmd("LocalConnectivity") # Get dut bt address self._dut_bt_address = self._bt_api.get_bt_adapter_address() else: self._dut_bt_address = "None" # Load instance of the PHONE2 self._phone2 = DeviceManager().get_device("PHONE2") if self._phone2 is not None: if not self._phone2.is_available(): self._phone2.switch_on(simple_switch_mode=True) self._voice_call_api2 = self._phone2.get_uecmd("VoiceCall") self._system_api2 = self._phone2.get_uecmd("System") else: self._voice_call_api2 = None self._system_api2 = None # Setup phone type ( calling, receiving, releasing phone) self._phone_calling = self._voice_call_api self._phone_receiving = self._voice_call_api2 self._calling_phone_number = self._phone2.get_phone_number() self._phone_releasing = self._voice_call_api2 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 None: # 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) # APx Initialization if self._audio_analyzer.initialization(self._device.get_phone_model(), self._test_type) != 0: error_msg = \ "APX Initialization Failed !" self._logger.error(error_msg) raise TestEquipmentException( TestEquipmentException.OPERATION_FAILED, error_msg) # Release any previous call (Robustness) self._voice_call_api.release() self._voice_call_api2.release() return Global.SUCCESS, "No errors" def run_test(self): """ Execute the test """ # Call UseCaseBase run_test function UseCaseBase.run_test(self) if self._acc_type == "HEADSET": if self._use_io_card: self._wired_headset.unplug_headphone() self._wired_headset.plug_whs() elif self._acc_type == "HEADPHONE": if self._use_io_card: self._wired_headset.unplug_whs() self._wired_headset.plug_headphone() # Dial using PHONE_NUMBER parameter self._phone_calling.dial(self._calling_phone_number) time.sleep(self._wait_btwn_cmd) # Wait for state "active" before callSetupTimeout seconds self._phone_receiving.wait_for_state( self._uecmd_types.VOICE_CALL_STATE.INCOMING, self._call_setup_time) # Answer call self._phone_receiving.answer() # Phone1 & 2 : Check voice call is active self._phone_calling.wait_for_state( self._uecmd_types.VOICE_CALL_STATE.ACTIVE, self._call_setup_time) self._phone_receiving.wait_for_state( self._uecmd_types.VOICE_CALL_STATE.ACTIVE, self._call_setup_time) # Configure Audio output to acc_type given with the test_case if self._acc_type == "EARPIECE": if self._use_io_card: self._wired_headset.unplug_whs() self._wired_headset.unplug_headphone() elif self._acc_type == "SPEAKER": # Switch to Speaker, nothing to do in Earpiece # Bluetooth already done with connect Bluetooth function above self._phonesystem_api.switch_audio_output(self._acc_type.lower()) time.sleep(self._wait_btwn_cmd) elif self._acc_type.find("BLUETOOTH") != -1: 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) if self._acc_type.find("BLUETOOTH") == -1: # Set Voice Call Volume self._system_api.adjust_specified_stream_volume( "VoiceCall", self._call_stream_volume_dut) else: # Set Voice Call Volume self._system_api.adjust_specified_stream_volume( "Bluetooth", self._call_stream_volume_dut) self._system_api2.adjust_specified_stream_volume( "VoiceCall", self._call_stream_volume_ref) # Launch Apx Calibration test on Uplink apx_result = self._audio_analyzer.calibration( self._device.get_phone_model(), "3G", self._acc_type, "UL", self._dut_bt_address) if apx_result == 0: self._result_verdict_ul = Global.SUCCESS self._verdict_comment = "APx Calibration success in UL" else: self._result_verdict_ul = Global.FAILURE self._verdict_comment = "APx Calibration fail in UL" # Launch Apx Calibration test on Downlink apx_result = self._audio_analyzer.calibration( self._device.get_phone_model(), "3G", self._acc_type, "DL", self._dut_bt_address) if apx_result == 0: self._result_verdict_dl = Global.SUCCESS self._verdict_comment += " and APx Calibration success in DL" else: self._result_verdict_dl = Global.FAILURE self._verdict_comment += " and APx Calibration fail in DL" # Compute final verdict if self._result_verdict_ul == Global.FAILURE or \ self._result_verdict_dl == Global.FAILURE: self._result_verdict_final = Global.FAILURE else: self._result_verdict_final = Global.SUCCESS # RELEASE THE CALL # Phone1 & 2 : Check call is still active self._phone_calling.check_state( self._uecmd_types.VOICE_CALL_STATE.ACTIVE) self._phone_receiving.check_state( self._uecmd_types.VOICE_CALL_STATE.ACTIVE) # Hang up call self._phone_releasing.release() # Phone1 & 2 : Check call is idle self._phone_calling.wait_for_state( self._uecmd_types.VOICE_CALL_STATE.NOCALL, self._call_setup_time) self._phone_receiving.wait_for_state( self._uecmd_types.VOICE_CALL_STATE.NOCALL, self._call_setup_time) return self._result_verdict_final, self._verdict_comment def tear_down(self): """ End and dispose the test """ # Call UseCaseBase tear_down function UseCaseBase.tear_down(self) if self._acc_type == "HEADSET": if self._use_io_card: self._wired_headset.unplug_whs() elif self._acc_type == "HEADPHONE": if self._use_io_card: self._wired_headset.unplug_headphone() # Release any previous call (Robustness) self._voice_call_api.release() self._voice_call_api2.release() # Reset Voice Call Volume at 70% if self._system_api is not None: self._system_api.adjust_specified_stream_volume("VoiceCall", 70) if self._system_api2 is not None: self._system_api2.adjust_specified_stream_volume("VoiceCall", 70) return Global.SUCCESS, "No errors"
class LabAudioQualityAccessoriesChangeBase(UseCaseBase): """ AudioComms Audio CSV Call Accessories Change class. """ 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 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 tear_down(self): """ End and dispose the test """ # Call UseCaseBase tear_down function UseCaseBase.tear_down(self) # Reset Voice Call Volume at 50% if self._system_api is not None: self._system_api.adjust_specified_stream_volume("VoiceCall", 70) if self._system_api2 is not None: self._system_api2.adjust_specified_stream_volume("VoiceCall", 70) return Global.SUCCESS, "No errors" def _compute_test_verdict_(self, audio_analyzer_result_ul, audio_analyzer_result_dl): """ Computes the test verdict for audio accessory change :type audio_analyzer_result_dl: int :param audio_analyzer_result_dl: result value for the DL audio test given by the audio analyzer :type audio_analyzer_result_ul: int :param audio_analyzer_result_ul: result value for the UL audio test given by the audio analyzer :return: None """ if self._audio_analyzer_result_save == 3: self._result_verdict = Global.BLOCKED elif self._audio_analyzer_result_save == 2: if (audio_analyzer_result_ul == 3) or (audio_analyzer_result_dl == 3): self._result_verdict = Global.BLOCKED self._failed_transition_no_audio = self._failed_transition_no_audio + ", " + \ self._previous_acc_type + " => " + self._acc_type self._audio_analyzer_result_save = 3 elif (audio_analyzer_result_ul == 2) or (audio_analyzer_result_dl == 2): self._result_verdict = Global.FAILURE self._failed_transition_no_audio = self._failed_transition_no_audio + ", " + \ self._previous_acc_type + " => " + self._acc_type self._audio_analyzer_result_save = 2 elif self._audio_analyzer_result_save == 1: if (audio_analyzer_result_ul == 3) or (audio_analyzer_result_dl == 3): self._result_verdict = Global.BLOCKED self._failed_transition_no_audio = self._failed_transition_no_audio + ", " + \ self._previous_acc_type + " => " + self._acc_type self._audio_analyzer_result_save = 3 elif (audio_analyzer_result_ul == 2) or (audio_analyzer_result_dl == 2): self._result_verdict = Global.FAILURE self._failed_transition_no_audio = self._failed_transition_no_audio + ", " + \ self._previous_acc_type + " => " + self._acc_type self._audio_analyzer_result_save = 2 elif (audio_analyzer_result_ul == 1) or (audio_analyzer_result_dl == 1): self._result_verdict = Global.FAILURE self._failed_transition_audio_pb = self._failed_transition_audio_pb + ", " + \ self._previous_acc_type + " => " + self._acc_type elif self._audio_analyzer_result_save == 0: if (audio_analyzer_result_ul == 3) or (audio_analyzer_result_dl == 3): self._result_verdict = Global.BLOCKED self._failed_transition_no_audio = self._failed_transition_no_audio + ", " + \ self._previous_acc_type + " => " + self._acc_type self._audio_analyzer_result_save = 3 elif (audio_analyzer_result_ul == 2) or (audio_analyzer_result_dl == 2): self._result_verdict = Global.FAILURE self._failed_transition_no_audio = self._failed_transition_no_audio + ", " + \ self._previous_acc_type + " => " + self._acc_type self._audio_analyzer_result_save = 2 elif (audio_analyzer_result_ul == 1) or (audio_analyzer_result_dl == 1): self._result_verdict = Global.FAILURE self._failed_transition_audio_pb = self._failed_transition_audio_pb + ", " + \ self._previous_acc_type + " => " + self._acc_type self._audio_analyzer_result_save = 1 else: self._audio_analyzer_result_save = 0 self._result_verdict = Global.SUCCESS # Now, the verdict comment will be updated, according to the outcome of the audio test if self._audio_analyzer_result_save == 0: self._verdict_comment = ( "Audio Quality test success: in %s with " "a %s call with %s accessories sequence" % (self._signal_tested_direction, self._call_type, str(self._tc_parameters.get_param_value("ACC_LIST")))) elif self._audio_analyzer_result_save == 1: self._verdict_comment = ( "Audio Quality test fail: Audio Analyzer quality audio " "problems detected in %s with a %s call with " "%s accessories sequence" % (self._signal_tested_direction, self._call_type, self._failed_transition_audio_pb)) elif self._audio_analyzer_result_save == 2: self._verdict_comment = ( "Audio Quality test fail: No audio signal in %s with " "a %s call with %s accessories sequence" % (self._signal_tested_direction, self._call_type, self._failed_transition_no_audio)) elif self._audio_analyzer_result_save == 3: self._verdict_comment = ( "Audio Quality test fail: Exception in executable in %s with " "a %s call with %s accessories sequence" % (self._signal_tested_direction, self._call_type, self._failed_transition_no_audio)) else: self._verdict_comment = ( "Audio Quality test fail: Audio Analyzer problems detected " "in %s with a %s call" % (self._signal_tested_direction, self._call_type))