class AndroidUiTestVcMt(AndroidUiTest):
"""
Android UI test mobile terminated voice call class.
This use case will permit to launch UI test on DUT.
The PHONE2 will be used in application framework level to make a voice call.
"""
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call Android UI test use case base Init function
AndroidUiTest.__init__(self, tc_name, global_config)
#
self._phone_number = \
str(self._device.get_phone_number())
# Read callSetupTimeout from Device_Catalog.xml
self._call_setup_time = \
int(self._dut_config.get("callSetupTimeout"))
# Get UECmdLayer
self._phone2 = DeviceManager().get_device("PHONE2")
if self._phone2 is not None:
self._voice_call_api2 = self._phone2.get_uecmd("VoiceCall")
def set_up(self):
"""
Set up the test configuration
"""
# Call Android UI test use case base Setup function
verdict, msg = AndroidUiTest.set_up(self)
if verdict != Global.SUCCESS:
return verdict, msg
# Check if we have the second phone available
if self._phone2 is None:
# We are using this multi UC with only one phone
return Global.FAILURE, "Cannot run that use case with only one phone configured."
# Boot the other phone (the DUT is already booted)
if self._phone2.get_state() != "alive":
# We are using this multi UC with an phone2 is not available
return Global.FAILURE, "Ref phone not available (power off ?), please check your bench."
if not self._phone2.is_available():
self._phone2.connect_board()
return Global.SUCCESS, "No error"
def run_test(self):
"""
Execute the test
"""
self._logger.info("")
self._logger.info("%s: RunTest", self._name)
self._logger.info("")
# Phone 2 : Release any previous call (Robustness)
time.sleep(self._wait_btwn_cmd)
self._voice_call_api2.release()
# Phone2 : Dial without checking call state (Non Blocking)
time.sleep(self._wait_btwn_cmd)
self._voice_call_api2.dial(self._phone_number, False)
# Phone1 : Call AndroidUiTest run test
return AndroidUiTest.run_test(self)
class LabWifiTetheringBase(LabWcdmaBase):
"""
Lab Wifi Tethering base Test class.
"""
_CHECK_CONNECTION_TIMEOUT = 20
def __init__(self, tc_name, global_config):
"""
Constructor
"""
LabWcdmaBase.__init__(self, tc_name, global_config)
# Get host spot configuration according HOTSPOT_SSID
self._hotspot_ssid = \
str(self._tc_parameters.get_param_value("HOTSPOT_SSID"))
# Get host spot configuration according HOTSPOT_SECURITY
self._hotspot_security = \
str(self._tc_parameters.get_param_value("HOTSPOT_SECURITY"))
# Get host spot configuration according HOTSPOT_PASSWORD
self._hotspot_passphrase = \
str(self._tc_parameters.get_param_value("HOTSPOT_PASSWORD"))
# Get UECmdLayer
self._networking_api = self._device.get_uecmd("Networking")
self._phone2 = DeviceManager().get_device("PHONE2")
if self._phone2 is not None:
self._networking_api2 = self._phone2.get_uecmd("Networking")
# init original wifi power status for phone1
self._original_wifi_power_status = 0
# Set BT prerequisite (set ON, set OFF or nothing) for FIT BT/WIFI tests
self._bt_fit_used, self._bt_wished_value = self._get_bt_fit_config()
# Instantiate generic UECmd
self._localconnectivity_api = self._device.get_uecmd(
"LocalConnectivity")
self._bt_initial_state = 'STATE_ON'
# MAC Address of the STA device that will be connected to the softAP
self._client_mac_address = ""
#------------------------------------------------------------------------------
def set_up(self):
"""
Initialize the test
"""
# run setup inherit from LabWcdmaBase
LabWcdmaBase.set_up(self)
# Check if we have the second phone available
if self._phone2 is None:
return Global.FAILURE, "Cannot run that use case with only one phone configured."
# Boot the other phone (the DUT is already booted)
if not self._phone2.is_available():
DeviceManager().boot_device("PHONE2")
# If Bt to be (de-)activated for FIT tests
if self._bt_fit_used:
self._bt_initial_state = self._localconnectivity_api.get_bt_power_status(
)
# if Bt is not at the wished value, set it to the correct one.
if self._bt_initial_state != self._bt_wished_value:
self._localconnectivity_api.set_bt_power(self._bt_wished_value)
time.sleep(self._wait_btwn_cmd)
# store original wifi power status
time.sleep(self._wait_btwn_cmd)
self._original_wifi_power_status = \
self._networking_api.get_wifi_power_status()
# disable wifi for Phone1
time.sleep(self._wait_btwn_cmd)
self._networking_api.set_wifi_power("off")
# enable Portable wifi hotspot for Phone1
time.sleep(self._wait_btwn_cmd)
self._networking_api.set_wifi_hotspot("on", self._hotspot_ssid,
self._hotspot_security,
self._hotspot_passphrase)
# set wifi power on for Phone2
time.sleep(self._wait_btwn_cmd)
self._networking_api2.set_wifi_power("on")
# Clear all data connections for Phone2
time.sleep(self._wait_btwn_cmd)
self._networking_api2.clean_all_data_connections()
# scan wifi for Phone2
time.sleep(self._wait_btwn_cmd)
self._networking_api2.request_wifi_scan()
# set passphrase for Phone2
if self._hotspot_security in "WPA2-PSK":
self._networking_api2.set_wificonfiguration(
self._hotspot_ssid, self._hotspot_passphrase,
self._hotspot_security)
# connect hotspot from Phone1 for Phone2
time.sleep(self._wait_btwn_cmd)
self._networking_api2.wifi_connect(self._hotspot_ssid)
# Retrieve the PHONE2 MAC address
time.sleep(self._wait_btwn_cmd)
self._client_mac_address = self._networking_api2.get_interface_mac_addr(
)
return Global.SUCCESS, "No errors"
#------------------------------------------------------------------------------
def tear_down(self):
"""
End and dispose the test
"""
LabWcdmaBase.tear_down(self)
status = Global.SUCCESS
msg = "No error"
# disconnect from hotspot for Phone2
time.sleep(self._wait_btwn_cmd)
self._networking_api2.\
wifi_disconnect(self._hotspot_ssid)
# set wifi power off for phone2
time.sleep(self._wait_btwn_cmd)
self._networking_api2.set_wifi_power("off")
# disable Portable wifi hotspot for Phone1
time.sleep(self._wait_btwn_cmd)
self._networking_api.set_wifi_hotspot("off")
# restore original wifi power status
time.sleep(self._wait_btwn_cmd)
self._networking_api.set_wifi_power(self._original_wifi_power_status)
# If Bt to be (de-)activated for FIT tests
if self._bt_fit_used:
bt_final_status = self._localconnectivity_api.get_bt_power_status()
# if Bt is not at the initial value, set it to the correct one.
if bt_final_status != self._bt_initial_state:
# restore Bt in initial state
self._localconnectivity_api.set_bt_power(
self._bt_initial_state)
time.sleep(self._wait_btwn_cmd)
return status, msg
#------------------------------------------------------------------------------
def _get_bt_fit_config(self):
"""
Get BT configuration for FIT BT/WIFI tests
:rtype: list of 2 elements (boolean, str)
:return: true if BT/WIFI FIT is used, Bluetooth state ON or OFF for the test to be run
"""
# Read WHILE_BLUETOOTH_ON parameter (named for retro-compatibility)
# from test case xml file for FIT tests
param_while_bt_on = \
str(self._tc_parameters.get_param_value("WHILE_BLUETOOTH_ON"))
if param_while_bt_on.lower() in ["1", "on", "true", "yes"]:
bt_fit_used = True
bt_wished_value = 'STATE_ON'
elif param_while_bt_on.lower() in ["0", "off", "false", "no"]:
bt_fit_used = True
bt_wished_value = 'STATE_OFF'
else:
bt_fit_used = False
bt_wished_value = 'STATE_OFF'
return bt_fit_used, bt_wished_value
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 LiveWifiTetheringRememberedSsid(LiveWifiTetheringBase):
"""
Live wifi Tethering ping.
"""
def __init__(self, tc_name, global_config): # pylint: disable=W0231
"""
Constructor
"""
# Call USECASE BASE Init function
LiveWifiTetheringBase.__init__(self, tc_name, global_config) # pylint: disable=W0233
# Get host spot configuration according HOTSPOT_SSID_BASENAME
self._hotspot_ssid_basename = \
str(self._tc_parameters.get_param_value("HOTSPOT_SSID_BASENAME"))
# Get host spot configuration according HOTSPOT_SECURITIES
self._hotspot_securities = \
str(self._tc_parameters.get_param_value("HOTSPOT_SECURITIES"))
self._hotspot_securities = self._hotspot_securities.split("|")
# Get UECmdLayer
self._networking_api = self._device.get_uecmd("Networking")
# Get PHONE2
self._networking_api2 = None
self._phone2 = DeviceManager().get_device("PHONE2")
if self._phone2 is not None:
self._networking_api2 = self._phone2.get_uecmd("Networking")
# init original wifi power status for phone1
self._original_wifi_power_status = 0
# init original flight mode for phone1
self._original_flight_mode = 0
self._interface_ip = None
self._hotspot_ext_interface = \
str(self._dut_config.get("hotspotExtInterface"))
# Read the number of pings to do
self._nb_pings = self._tc_parameters.get_param_value("PACKET_COUNT")
# Read the data size of a packet
self._packet_size = self._tc_parameters.get_param_value("PACKET_SIZE")
# Get target % of received packet for ping
self._target_ping_packet_loss_rate = \
float(self._tc_parameters.get_param_value("TARGET_PACKET_LOSS_RATE"))
self._waiting_time = \
int(self._tc_parameters.get_param_value("DELAY_AFTER_PING"))
# Get the IP server to ping
self._server_ip = self._tc_parameters.\
get_param_value("SERVER_TO_PING")
self._server_2_ping = None
# Set BT prerequisite (set ON, set OFF or nothing) for FIT BT/WIFI tests
self._bt_fit_used, self._bt_wished_value = LiveWifiTetheringBase._get_bt_fit_config(
self)
# Instantiate generic UECmd
self._localconnectivity_api = self._device.get_uecmd(
"LocalConnectivity")
self._bt_initial_state = 'STATE_ON'
#------------------------------------------------------------------------------
def set_up(self):
"""
Initialize the test
"""
UseCaseBase.set_up(self)
# Check if we have second wifi interface or second phone available
if self._networking_api2 is None:
msg = "PHONE2 is required in BenchConfig"
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
# store original wifi power status
time.sleep(self._wait_btwn_cmd)
self._original_wifi_power_status = \
self._networking_api.get_wifi_power_status()
# store original flight mode
time.sleep(self._wait_btwn_cmd)
self._original_flight_mode = self._networking_api.get_flight_mode()
# Enable/Disable flight mode
if str_to_bool_ex(self._original_flight_mode) != str_to_bool_ex(
self._flight_mode):
time.sleep(self._wait_btwn_cmd)
self._networking_api.set_flight_mode(self._flight_mode)
# Enable Cellular Data connection
if self._flight_mode == False and self._is_pdp_context_activated:
time.sleep(self._wait_btwn_cmd)
self._networking_api.activate_pdp_context()
# disable wifi for Phone1
time.sleep(self._wait_btwn_cmd)
self._networking_api.set_wifi_power("off")
time.sleep(self._wait_btwn_cmd)
self._networking_api.set_wifi_hotspot("off")
# Boot the other phone (the DUT is already booted)
if self._phone2.get_state() != "alive" \
or not self._phone2.is_available():
DeviceManager().boot_device("PHONE2")
# If Bt to be (de-)activated for FIT tests
if self._bt_fit_used:
self._bt_initial_state = self._localconnectivity_api.get_bt_power_status(
)
# if Bt is not at the wished value, set it to the correct one.
if self._bt_initial_state != self._bt_wished_value:
self._localconnectivity_api.set_bt_power(self._bt_wished_value)
time.sleep(self._wait_btwn_cmd)
# set wifi power on for Phone2
time.sleep(self._wait_btwn_cmd)
self._networking_api2.set_wifi_power("on")
# disconnect all wifi for Phone2
time.sleep(self._wait_btwn_cmd)
self._networking_api2.wifi_remove_config("all")
# Set networks as remembered SSIDs
for security in self._hotspot_securities:
# Build the SSID name
ssid = self._hotspot_ssid_basename + "_" + security
# set ssid for Phone2 as remembered network
time.sleep(self._wait_btwn_cmd)
self._networking_api2.set_wificonfiguration(
ssid, self._hotspot_passphrase, security)
# Need to restart Wifi interface to enable SSIDs
self._networking_api2.set_wifi_power(0)
time.sleep(self._wait_btwn_cmd)
self._networking_api2.set_wifi_power(1)
time.sleep(self._wait_btwn_cmd)
self._networking_api2.set_wifi_sleep_policy(
self._networking_api.WIFI_SLEEP_POLICY["NEVER"])
return Global.SUCCESS, "No error"
#------------------------------------------------------------------------------
def run_test(self):
"""
Execute the test
"""
UseCaseBase.run_test(self)
self._error.Msg = ""
self._error.Code = Global.SUCCESS
for security in self._hotspot_securities:
# Build the SSID name
ssid = self._hotspot_ssid_basename + "_" + security
# enable Portable wifi hotspot for Phone1
time.sleep(self._wait_btwn_cmd)
self._networking_api.set_wifi_hotspot("off")
time.sleep(self._wait_btwn_cmd)
self._networking_api.set_wifi_hotspot("on", ssid, security,
self._hotspot_passphrase)
# Wait for the PHONE2 to auto connect
self._logger.info("Waiting 60 sec for the connection to establish")
time.sleep(60)
self._networking_api2.check_connection_state(ssid)
# Correct the IP server 2 ping if necessary, once
if self._server_2_ping is None:
if str(self._server_ip) in ["None", ""] or self._flight_mode:
# Get the IP of the softAP wifi interface
self._server_2_ping = self._networking_api.\
get_interface_ipv4_address(self._hotspot_ext_interface)
if str(self._server_ip) not in ["None", ""] \
and self._flight_mode:
# Display a warning because the given parameter
# cannot be used
self._logger.warning("IP server set as parameter " +
"is ignored, as test is run " +
"in flight mode. Using SoftAP" +
" IP instead (%s)" %
self._server_2_ping)
else:
self._server_2_ping = self._server_ip
# ping phone1 from phone2
packet_loss = self._networking_api2.ping(self._server_2_ping,
self._packet_size,
self._nb_pings)
msg = "[%s] Measured Packet Loss: %.0f%s (Target: %.0f%s) - " \
% (security,
packet_loss.value,
packet_loss.units,
self._target_ping_packet_loss_rate,
packet_loss.units)
self._logger.info(msg)
self._error.Msg += msg
# Compute verdict depending on % of packet loss
if packet_loss.value > self._target_ping_packet_loss_rate:
msg = "Ping packet loss is not acceptable [%s]" \
% str(packet_loss.value)
self._logger.error(msg)
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
if self._waiting_time > 0:
self._logger.info("Waiting for %s sec" %
str(self._waiting_time))
time.sleep(self._waiting_time)
return self._error.Code, self._error.Msg
def tear_down(self):
"""
End and dispose the test
"""
LiveWifiTetheringBase.tear_down(self)
if self._networking_api2 is not None:
# disconnect from hotspot for Phone2
time.sleep(self._wait_btwn_cmd)
self._networking_api2.wifi_remove_config("all")
# set wifi power off for phone2
time.sleep(self._wait_btwn_cmd)
self._networking_api2.set_wifi_power("off")
# disable Portable wifi hotspot for Phone1
time.sleep(self._wait_btwn_cmd)
self._networking_api.set_wifi_hotspot("off")
return Global.SUCCESS, "No error"
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))
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 LiveWifiTetheringBase(UseCaseBase):
"""
Live Wifi Tethering base Test class.
"""
_CHECK_CONNECTION_TIMEOUT = 20
def __init__(self, tc_name, global_config):
"""
Constructor
"""
UseCaseBase.__init__(self, tc_name, global_config)
# Get FTP server parameters
self._wifi_server = global_config.benchConfig.get_parameters(
"WIFI_SERVER")
self._ftp_ip_address = self._wifi_server.get_param_value("IP")
self._ftp_username = self._wifi_server.get_param_value("username")
self._ftp_password = self._wifi_server.get_param_value("password")
if self._wifi_server.has_parameter("ftp_path"):
self._ftp_path = self._wifi_server.get_param_value("ftp_path")
else:
self._ftp_path = ""
# Get host spot configuration according HOTSPOT_SSID
self._hotspot_ssid = \
str(self._tc_parameters.get_param_value("HOTSPOT_SSID"))
# Get host spot configuration according HOTSPOT_SECURITY
self._hotspot_security = \
str(self._tc_parameters.get_param_value("HOTSPOT_SECURITY"))
# Get host spot configuration according HOTSPOT_PASSWORD
self._hotspot_passphrase = \
str(self._tc_parameters.get_param_value("HOTSPOT_PASSWORD"))
# Get host spot configuration according HOTSPOT_STANDARD
self._hotspot_standard = \
self._tc_parameters.get_param_value("HOTSPOT_STANDARD")
# Get flight mode configuration according FLIGHT_MODE
self._flight_mode = \
str(self._tc_parameters.get_param_value("FLIGHT_MODE"))
self._flight_mode = str_to_bool_ex(self._flight_mode)
# Get Data connection mode
self._is_pdp_context_activated = \
str(self._tc_parameters.get_param_value("IS_PDP_CONTEXT_ACTIVATED"))
self._is_pdp_context_activated = str_to_bool_ex(
self._is_pdp_context_activated)
# Default is True
if self._is_pdp_context_activated == None:
self._is_pdp_context_activated = True
# Get the optional DUT wrong passphrase to test connection failure
self._wrong_passphrase = self._tc_parameters. \
get_param_value("WIFI_PASSPHRASE")
# Get computer type
self._computer = self._tc_parameters.get_param_value("COMPUTER")
if self._computer == "":
self._computer = None # empty computer: use second DUT
# Get UECmdLayer
self._networking_api = self._device.get_uecmd("Networking")
# Load computer equipment
if self._computer is not None:
self._computer = self._em.get_computer(self._computer)
self._wifi_interface = self._computer.get_wifi_interface()
if self._wifi_interface == "":
self._wifi_interface = None
else:
self._wifi_interface = None
# Get PHONE2
self._phone2 = None
self._networking_api2 = None
if self._computer is None:
self._phone2 = DeviceManager().get_device("PHONE2")
if self._phone2 is not None:
self._networking_api2 = self._phone2.get_uecmd("Networking")
# init original wifi power status for phone1
self._original_wifi_power_status = 0
# init original flight mode for phone1
self._original_flight_mode = 0
self._interface_ip = None
self._hotspot_ext_interface = \
str(self._dut_config.get("hotspotExtInterface"))
# Set BT prerequisite (set ON, set OFF or nothing) for FIT BT/WIFI tests
self._bt_fit_used, self._bt_wished_value = self._get_bt_fit_config()
# BT initial state
self._bt_initial_state = 'STATE_ON'
# Instantiate generic UECmd
self._localconnectivity_api = self._device.get_uecmd(
"LocalConnectivity")
# MAC Address of the STA device that will be connected to the softAP
self._client_mac_address = ""
#------------------------------------------------------------------------------
def set_up(self):
"""
Initialize the test
"""
# pylint: disable=E1101
# run setup inherit from UseCaseBase
UseCaseBase.set_up(self)
# Check if we have second wifi interface or second phone available
if (self._computer is None or self._wifi_interface is None) \
and self._phone2 is None:
msg = "Cannot run that use case without a remote PC or with only one phone configured."
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
# If Bt to be (de-)activated for FIT tests
if self._bt_fit_used:
self._bt_initial_state = self._localconnectivity_api.get_bt_power_status(
)
# if Bt is not at the wished value, set it to the correct one.
if self._bt_initial_state != self._bt_wished_value:
self._localconnectivity_api.set_bt_power(self._bt_wished_value)
time.sleep(self._wait_btwn_cmd)
# store original wifi power status
time.sleep(self._wait_btwn_cmd)
self._original_wifi_power_status = \
self._networking_api.get_wifi_power_status()
# store original flight mode
time.sleep(self._wait_btwn_cmd)
self._original_flight_mode = self._networking_api.get_flight_mode()
# Enable/Disable flight mode
time.sleep(self._wait_btwn_cmd)
self._networking_api.set_flight_mode(self._flight_mode)
# Enable Cellular Data connection
if self._flight_mode == False and self._is_pdp_context_activated:
time.sleep(self._wait_btwn_cmd)
self._networking_api.activate_pdp_context()
# disable wifi for Phone1
time.sleep(self._wait_btwn_cmd)
self._networking_api.set_wifi_power("off")
# enable Portable wifi hotspot for Phone1
time.sleep(self._wait_btwn_cmd)
self._networking_api.set_wifi_hotspot("on", self._hotspot_ssid,
self._hotspot_security,
self._hotspot_passphrase)
if self._wrong_passphrase in (None, "", "NONE", "None"):
passphrase = self._hotspot_passphrase
wrong_passphrase = False
else:
passphrase = self._wrong_passphrase
wrong_passphrase = True
if self._computer is not None:
try:
self._interface_ip = \
self._computer.wifi_connect(self._wifi_interface,
self._hotspot_standard,
self._hotspot_ssid,
self._hotspot_security,
passphrase)
if wrong_passphrase:
msg = "Connection successful with wrong passphrase."
self._logger.error(msg)
raise TestEquipmentException(
TestEquipmentException.OPERATION_FAILED, msg)
except TestEquipmentException as exc:
# ignore the exception if the connection fails with a wrong passphrase
if not wrong_passphrase:
raise
elif not "Could not get IP address" in str(exc) \
and not "Could not associate device" in str(exc):
raise
# Retrieve the MAC address of the COMPUTER
time.sleep(self._wait_btwn_cmd)
self._client_mac_address = self._computer.get_interface_mac_addr(
self._wifi_interface)
self._client_mac_address.lower()
elif self._phone2 is not None:
# Boot the other phone (the DUT is already booted)
if not self._phone2.is_available():
DeviceManager().boot_device("PHONE2")
# set wifi power on for Phone2
time.sleep(self._wait_btwn_cmd)
self._networking_api2.set_wifi_power("on")
# set auto connect state off for Phone2
time.sleep(self._wait_btwn_cmd)
self._networking_api2.\
set_autoconnect_mode("all",
self._uecmd_types.AUTO_CONNECT_STATE.off)
# disconnect all wifi for Phone2
time.sleep(self._wait_btwn_cmd)
self._networking_api2.wifi_disconnect_all()
# set passphrase for Phone2
self._networking_api2.set_wificonfiguration(
self._hotspot_ssid, passphrase, self._hotspot_security)
# connect hotspot from Phone1 for Phone2
time.sleep(self._wait_btwn_cmd)
try:
self._networking_api2.wifi_connect(self._hotspot_ssid)
if wrong_passphrase:
msg = "Connection successful with wrong passphrase."
self._logger.error(msg)
raise DeviceException(DeviceException.OPERATION_FAILED,
msg)
except AcsBaseException as exc:
# ignore the exception if the connection fails with a wrong passphrase
if not wrong_passphrase:
raise
elif not "timeout" in str(exc):
raise
# Retrieve the MAC address of the PHONE2
time.sleep(self._wait_btwn_cmd)
self._client_mac_address = self._networking_api2.get_interface_mac_addr(
).lower()
else:
msg = "Cannot run that use case without a remote PC or with only one phone configured."
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
return Global.SUCCESS, "No error"
#------------------------------------------------------------------------------
def tear_down(self):
"""
End and dispose the test
"""
UseCaseBase.tear_down(self)
status = Global.SUCCESS
msg = "No error"
if self._computer is not None:
self._computer.wifi_disconnect(self._wifi_interface)
elif self._phone2 is not None:
# disconnect from hotspot for Phone2
time.sleep(self._wait_btwn_cmd)
self._networking_api2.\
wifi_disconnect(self._hotspot_ssid)
time.sleep(self._wait_btwn_cmd)
self._networking_api2.wifi_remove_config(self._hotspot_ssid)
# set wifi power off for phone2
time.sleep(self._wait_btwn_cmd)
self._networking_api2.set_wifi_power("off")
# disable Portable wifi hotspot for Phone1
time.sleep(self._wait_btwn_cmd)
self._networking_api.set_wifi_hotspot("off")
# restore original flight mode
if str_to_bool_ex(self._original_flight_mode) != str_to_bool_ex(
self._flight_mode):
time.sleep(self._wait_btwn_cmd)
self._networking_api.set_flight_mode(self._original_flight_mode)
# restore original wifi power status
time.sleep(self._wait_btwn_cmd)
self._networking_api.set_wifi_power(self._original_wifi_power_status)
# If Bt to be (de-)activated for FIT tests
if self._bt_fit_used:
bt_final_status = self._localconnectivity_api.get_bt_power_status()
# if Bt is not at the initial value, set it to the correct one.
if bt_final_status != self._bt_initial_state:
# restore Bt in initial state
self._localconnectivity_api.set_bt_power(
self._bt_initial_state)
time.sleep(self._wait_btwn_cmd)
return status, msg
#------------------------------------------------------------------------------
def _get_bt_fit_config(self):
"""
Get BT configuration for FIT BT/WIFI tests
:rtype: list of 2 elements (boolean, str)
:return: true if BT/WIFI FIT is used, Bluetooth state ON or OFF for the test to be run
"""
# Read WHILE_BLUETOOTH_ON parameter (named for retro-compatibility)
# from test case xml file for FIT tests
param_while_bt_on = \
str(self._tc_parameters.get_param_value("WHILE_BLUETOOTH_ON"))
if param_while_bt_on.lower() in ["1", "on", "true", "yes"]:
bt_fit_used = True
bt_wished_value = 'STATE_ON'
elif param_while_bt_on.lower() in ["0", "off", "false", "no"]:
bt_fit_used = True
bt_wished_value = 'STATE_OFF'
else:
bt_fit_used = False
bt_wished_value = 'STATE_OFF'
return bt_fit_used, bt_wished_value
class LiveLteImsVcDualBase(LiveLteImsReg):
"""
This test case requires a Com4Innov cell to work.
Because of this constraint some values that should
have been given as parameters are actually hard-coded.
That is to be changed if this test ever has to be
executed in a different environment.
"""
def __init__(self, tc_name, global_config):
"""
Initializes this instance.
"""
# Call inherited initializer
LiveLteImsReg.__init__(self, tc_name, global_config)
# Read the call direction parameter
self._call_direction = str(
self._tc_parameters.get_param_value("CALL_DIRECTION", "MO"))
# Read the call release parameter
self._call_release_direction = str(
self._tc_parameters.get_param_value("CALL_RELEASE", "MR"))
# Read the call type parameter
self._call_type = self._tc_parameters.get_param_value("CALL_TYPE", "")
# Retrieve call duration parameter
self._callduration = \
int(self._tc_parameters.get_param_value("CALL_DURATION", 15))
# Read the parameter for call on hold/resume procedure
self._check_on_hold_resume_procedure = str_to_bool(
self._tc_parameters.get_param_value("CHECK_CALL_ON_HOLD_RESUME",
"False"))
# Read the call option parameter for remote party
self._remote_party_action = \
self._tc_parameters.get_param_value("REMOTE_PARTY_ACTION", "")
# Initialize some attributes to store various phone numbers
self._phone_no_main_dut = None
self._phone_no_secondary_dut = None
# Read the phone number parameter from TC's XML
self._phone_number = self._tc_parameters.get_param_value(
"PHONE_NUMBER")
# If Phone number is not specified in TC XML, try to retrieve it from bench config
if self._phone_number is None:
# Retrieve the numbers for each phone used, from bench config file
self._phone_no_main_dut = \
self._retrive_parameter_bench_config(global_config, "PhoneNumberDut1")
self._phone_no_secondary_dut = \
self._retrive_parameter_bench_config(global_config, "PhoneNumberDut2")
if self._ims_reg_operation == "CHECK_ONLY":
self._perform_ims_registration = False
else:
self._perform_ims_registration = True
# Read the ftp transfer parameter
self._ftp_transfer = str_to_bool(
self._tc_parameters.get_param_value("FTP_TRANSFER", "False"))
if self._ftp_transfer is True:
# Retrieve the parameters needed for FTP data transfer
self._retrieve_ftp_parameters(global_config)
# Instantiate the FTP UE commands for main device
self._ftp_api = self._device.get_uecmd("Ftp")
else:
# Initialize the FTP parameters
self._ftp_api = None
self._server = None
self._server_ip_v4_address = None
self._server_ip_v6_address = None
self._username = None
self._password = None
self._ftp_path = None
self._ftp_direction = None
self._ftp_filename = None
self._dl_ftp_filename = None
self._ftp_ip_version = None
self._ip_address = None
self._xfer_timeout = None
# Read callSetupTimeout from Phone_Catalog.xml
self._call_setup_time = \
int(self._dut_config.get("callSetupTimeout"))
# Instantiate UE categories for first device
self._voice_call_api = self._device.get_uecmd("VoiceCall")
self._networking_api = self._device.get_uecmd("Networking")
self._file_system_api = self._device.get_uecmd("File")
self._phone_system_api = self._device.get_uecmd("PhoneSystem")
# Load instance of the PHONE2
self._remote_phone = DeviceManager().get_device("PHONE2")
self._remote_dut_config = DeviceManager().get_device_config("PHONE2")
# Instantiate UE categories for second device
if self._remote_phone is not None:
self._voice_call_api2 = self._remote_phone.get_uecmd("VoiceCall")
self._networking_api2 = self._remote_phone.get_uecmd("Networking")
self._phone_system_api2 = self._remote_phone.get_uecmd(
"PhoneSystem")
else:
self._voice_call_api2 = None
self._networking_api2 = None
self._phone_system_api2 = None
#------------------------------------------------------------------------------
def set_up(self):
"""
Initializes the test.
"""
# Call the inherited set_up method
# Ugly temporary solution before implementing something
# better using test steps.
if self._perform_ims_registration:
# Call inherited setup method
self._logger.info("Performing IMS registration step as requested.")
LiveLteImsReg.set_up(self)
else:
# Call the base setup method in order to be
# compliant with ACS framework
self._logger.info(
"Skipping IMS registration step (assumed to be done).")
UseCaseBase.set_up(self)
if self._perform_ims_registration is None:
# But raise an exception
message = "Invalid parameter value for IMS_REGISTRATION_OPERATION"
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
message)
# Simply perform a IMS registration check
self._networking_api.check_ims_registration_before_timeout(10)
# Check the call duration parameter
if not self._callduration:
message = "%s '%s' %s '%s'" % (
"Invalid parameter value (or missing parameter)",
str(self._callduration), "for parameter", "CALL_DURATION")
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
message)
# We arbitrarily set a minimum allowed value for call duration
if self._callduration < 15:
message = "%s '%s' %s '%s'. %s." % (
"Invalid parameter value ", str(
self._callduration), "for parameter", "CALL_DURATION",
"The value should be set to 15 at the minimum")
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
message)
# Check the call type parameter
if self._call_type not in ("IR92", "IR94_AUDIO", "IR94_RX", "IR94_TX",
"IR94_BIDIRECTIONAL"):
message = "%s '%s' %s '%s'" % (
"Invalid parameter value (or missing parameter)",
str(self._call_type), "for parameter", "CALL_TYPE")
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
message)
# Check the call type parameter
if self._call_direction not in ("MO", "MT"):
message = "%s '%s' %s '%s'" % (
"Invalid parameter value (or missing parameter)",
str(self._call_direction), "for parameter", "CALL_DIRECTION")
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
message)
# Check the call type parameter
if self._call_release_direction not in ("MR", "NR"):
message = "%s '%s' %s '%s'" % ("Invalid parameter value",
str(self._call_release_direction),
"for parameter", "CALL_RELEASE")
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
message)
# Check if we have the second phone available
if self._remote_phone is None:
# We are using this multi UC with only one phone
message = \
"This use case requires two phones to be executed !"
self._logger.error(message)
raise AcsConfigException(AcsConfigException.INVALID_BENCH_CONFIG,
message)
# Boot the other phone (the DUT is already booted)
if not self._remote_phone.is_available():
DeviceManager().boot_device("PHONE2")
# Disable Flight Mode for the secondary DUT (robustness)
self._networking_api2.set_flight_mode("off")
# Set up is done correctly
return (Global.SUCCESS, "No errors")
#------------------------------------------------------------------------------
def run_test(self):
"""
Runs the test.
"""
# Call inherited run_test method which will ensure IMS registration
# Ugly temporary solution before implementing something
# better using test steps.
if self._perform_ims_registration:
LiveLteImsReg.run_test(self)
else:
UseCaseBase.run_test(self)
# Check registration for secondary DUT
self._check_registration_second_dut()
# Release any previous call (Robustness)
self._logger.info("Releasing any ongoing calls")
self._voice_call_api.release()
self._voice_call_api2.release()
# Return the test result
return (Global.SUCCESS, "No error.")
#------------------------------------------------------------------------------
def tear_down(self):
"""
Disposes this test.
"""
# Call the inherited tear_down method
# Ugly temporary solution before implementing something
# better using test steps.
if self._perform_ims_registration:
LiveLteImsReg.tear_down(self)
else:
UseCaseBase.tear_down(self)
# End of tear_down
return (Global.SUCCESS, "No errors")
def _retrieve_ftp_parameters(self, global_config):
"""
Read and set the FTP parameters from bench config and TC's .XML files.
"""
# Get FTP server parameters from bench config file
self._server = \
global_config.benchConfig.get_parameters("LAB_LTE_IMS_SERVER")
self._server_ip_v4_address = self._server.get_param_value("IP4")
self._server_ip_v6_address = self._server.get_param_value("IP6")
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 the the direction parameter name from TC's xml file
self._ftp_direction = self._tc_parameters.get_param_value(
"FTP_DIRECTION")
# Read the ftp file name from TC's xml
if self._ftp_direction == "DL":
self._ftp_filename = os.path.join(
self._ftp_path,
self._tc_parameters.get_param_value("DL_FILENAME", ""))
self._ftp_filename = self._ftp_filename.replace('\\', '/')
self._dl_ftp_filename = None
elif self._ftp_direction == "UL":
# Read the UL_FILENAME value from TC's xml
self._ftp_filename = os.path.join(
self._ftp_path,
self._tc_parameters.get_param_value("UL_FILENAME", ""))
self._ftp_filename = self._ftp_filename.replace('\\', '/')
self._dl_ftp_filename = None
elif self._ftp_direction == "BOTH":
self._dl_ftp_filename = os.path.join(
self._ftp_path,
self._tc_parameters.get_param_value("DL_FILENAME", ""))
self._dl_ftp_filename = self._dl_ftp_filename.replace('\\', '/')
# Read the UL_FILE value from TC's xml
self._ftp_filename = os.path.join(
self._ftp_path,
self._tc_parameters.get_param_value("UL_FILENAME", ""))
self._ftp_filename = self._ftp_filename.replace('\\', '/')
# Read the the ip_version from TC's xml
self._ftp_ip_version = self._tc_parameters.get_param_value(
"FTP_IP_VERSION", "IPV4")
# Selecting the IPV6 address of the FTP server, according to
# the TC parameter value.
if self._ftp_ip_version == "IPV6":
if self._server_ip_v6_address is not None:
# If Protocol is IPV6 use IPV6 address.
log_msg = "Using IPV6 address to connect to the FTP server."
self._logger.info(log_msg)
self._ip_address = self._server_ip_v6_address
else:
# If IPV6 address is not present in the BenchConfig.
msg = "The IPV6 parameter is missing from the Bench Config!"
raise AcsConfigException(
AcsConfigException.INVALID_BENCH_CONFIG, msg)
else:
self._ip_address = self._server_ip_v4_address
# Read the XFER_TIMEOUT from UseCase xml Parameter
self._xfer_timeout = self._tc_parameters.get_param_value(
"XFER_TIMEOUT")
if self._xfer_timeout is not None and str(
self._xfer_timeout).isdigit():
self._xfer_timeout = int(self._xfer_timeout)
else:
self._xfer_timeout = None
def _check_ftp_parameters(self):
"""
Check the parameters related with FTP data transfer
:raise AcsConfigException: in case any parameter is incorrect
"""
# Check the call type parameter
if self._ftp_direction not in ("DL", "UL", "BOTH"):
message = "%s '%s' %s '%s'" % (
"Invalid parameter value (or missing parameter)",
str(self._ftp_direction), "for parameter", "FTP_DIRECTION")
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
message)
if self._xfer_timeout is None:
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
"XFER_TIMEOUT should be int")
def _check_registration_second_dut(self):
"""
Check if secondary DUT is registered or not to NW
:raise DeviceException: in case 2nd DUT not registered
"""
in_service_status = ImsRegistrationStatus.in_service()
reg_status = ImsRegistrationStatus(
self._networking_api2.get_ims_registration_status())
# If not registered
if reg_status != in_service_status:
self._logger.warning(
"The secondary DUT is NOT registered! Airplane on/off will be performed!"
)
self._networking_api2.set_flight_mode("on")
# Wait 10 seconds
time.sleep(10)
self._networking_api2.set_flight_mode("off")
# Wait 10 seconds
time.sleep(10)
try:
self._networking_api2.check_ims_registration_before_timeout(60)
except DeviceException:
message = "Secondary DUT still not registered after airplane on/off !"
raise DeviceException(DeviceException.TIMEOUT_REACHED, message)
class LiveDualPhoneBTBase(LiveBTBase):
"""
Live BT Test base class.
"""
# Constants
STR_PHONE_2 = "PHONE2"
def __init__(self, tc_name, global_config):
"""
Constructor
"""
LiveBTBase.__init__(self, tc_name, global_config)
# Get PHONE2
self._phone2 = DeviceManager().get_device(self.STR_PHONE_2)
# Check if we have the second phone available
if self._phone2 is not None:
if not self._phone2.is_available():
DeviceManager().boot_device(self.STR_PHONE_2)
self._bt_api2 = self._phone2.get_uecmd("LocalConnectivity")
# Get PHONE2 networking interface
self._networking_api2 = self._phone2.get_uecmd("Networking")
# Get BT device parameters
self._dut2_config = DeviceManager().get_device_config(self.STR_PHONE_2)
self._phone_system_api = self._device.get_uecmd("PhoneSystem")
# Initialize phones address
self._phone1_addr = ""
self._phone2_addr = ""
self._original_flight_mode2 = 0
#------------------------------------------------------------------------------
def set_up(self):
"""
Initialize the test
"""
LiveBTBase.set_up(self)
if self._phone2 is None:
msg = "PHONE2 is not specified in the bench configuration"
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_BENCH_CONFIG, msg)
# Get original phone mode
self._original_flight_mode2 = self._networking_api2.get_flight_mode()
# Flight mode
if self._use_flightmode != self._original_flight_mode2:
self._networking_api2.set_flight_mode(self._use_flightmode)
self._logger.info("Reset phone Bluetooth adapter")
self._bt_api2.bt_reset_device()
# Get phones address
self._phone1_addr = self._bt_api.get_bt_adapter_address()
self._phone2_addr = self._bt_api2.get_bt_adapter_address()
return Global.SUCCESS, "No errors"
#------------------------------------------------------------------------------
def tear_down(self):
"""
End and dispose the test
"""
LiveBTBase.tear_down(self)
time.sleep(self._wait_btwn_cmd)
# Recover to initial flight mode
self._logger.info("Set PHONE2 to original flight mode")
self._networking_api2.set_flight_mode(self._original_flight_mode2)
time.sleep(self._wait_btwn_cmd)
self._logger.info("Close phone 2 adapter devices")
self._bt_api2.set_bt_power("off")
time.sleep(self._wait_btwn_cmd)
return Global.SUCCESS, "No errors"
def _establish_bt_pairing(self, pairing_initiator):
"""
Establish bluetooth pairing procedure
:type pairing_initiator: String
:param pairing_initiator: PHONE1 or PHONE2 the device that requests for pairing first
"""
# Defines BT pairing roles
if pairing_initiator == "PHONE2":
paired_api = self._bt_api
paired_addr = self._phone1_addr
requester_api = self._bt_api2
requester_addr = self._phone2_addr
else:
paired_api = self._bt_api2
paired_addr = self._phone2_addr
requester_api = self._bt_api
requester_addr = self._phone1_addr
establish_bt_pairing(requester_api, requester_addr,
paired_api, paired_addr,
self._wait_btwn_cmd)
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 LiveDualPhoneVcBase(UseCaseBase):
"""
Live Voice Call base class.
"""
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call init of use case base
UseCaseBase.__init__(self, tc_name, global_config)
# Get Test Cases Parameters
self._callduration = \
int(self._tc_parameters.get_param_value("CALL_DURATION"))
# Read callSetupTimeout from Phone_Catalog.xml
self._call_setup_time = \
int(self._dut_config.get("callSetupTimeout"))
# Get UECmdLayer
self._voice_call_api = self._device.get_uecmd("VoiceCall")
self._networking_api = self._device.get_uecmd("Networking")
# Load instance of the PHONE2
self._phone2 = DeviceManager().get_device("PHONE2")
if self._phone2 is not None:
self._voice_call_api2 = self._phone2.get_uecmd("VoiceCall")
self._networking_api2 = self._phone2.get_uecmd("Networking")
else:
self._voice_call_api2 = None
self._networking_api2 = None
# Instantiate the instances for phone caller, receiver and releaser
self._caller_phone = None
self._receiver_phone = None
self._releaser_phone = None
#------------------------------------------------------------------------------
def set_up(self):
"""
Initialize the test
"""
# Call set_up of use case base
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 use case requires two phones to be executed !"
self._logger.error(error_msg)
raise AcsConfigException(AcsConfigException.INVALID_BENCH_CONFIG,
error_msg)
# Boot the other phone (the DUT is already booted)
if not self._phone2.is_available():
DeviceManager().boot_device("PHONE2")
# Disable flight mode
self._networking_api.set_flight_mode("off")
self._networking_api2.set_flight_mode("off")
return Global.SUCCESS, "No errors"
#------------------------------------------------------------------------------
def run_test(self):
"""
Execute the test
"""
# pylint: disable-msg=E1101
# This to avoid pylint warnings due to enum class VOICE_CALL_STATE
# Call init of use case base
UseCaseBase.run_test(self)
# Release any previous call (Robustness)
time.sleep(self._wait_btwn_cmd)
self._voice_call_api.release()
self._voice_call_api2.release()
# ESTABLISH THE CALL
# Phone1 : Dial
time.sleep(self._wait_btwn_cmd)
self._caller_phone.dial(self._phone_number, False)
# Phone2 : Wait for state incoming before callSetupTimeout seconds
self._receiver_phone.wait_for_state(
self._uecmd_types.VOICE_CALL_STATE.INCOMING, self._call_setup_time)
# Phone2 : Answer call
self._receiver_phone.answer()
# Phone1 & 2 : Check voice call is active
self._voice_call_api.wait_for_state(
self._uecmd_types.VOICE_CALL_STATE.ACTIVE, self._call_setup_time)
self._voice_call_api2.wait_for_state(
self._uecmd_types.VOICE_CALL_STATE.ACTIVE, self._call_setup_time)
# WAIT FOR CALL DURATION
self._logger.info("Wait for call duration: " +
str(self._callduration) + "s...")
time.sleep(self._callduration)
# RELEASE THE CALL
# Phone1 & 2 : Check call is still active
self._voice_call_api.check_state(
self._uecmd_types.VOICE_CALL_STATE.ACTIVE)
self._voice_call_api2.check_state(
self._uecmd_types.VOICE_CALL_STATE.ACTIVE)
# Phone1 : Release the call
time.sleep(self._wait_btwn_cmd)
self._releaser_phone.release()
# Phone1 & 2 : Check call is idle
self._voice_call_api.wait_for_state(
self._uecmd_types.VOICE_CALL_STATE.NOCALL, self._call_setup_time)
self._voice_call_api2.wait_for_state(
self._uecmd_types.VOICE_CALL_STATE.NOCALL, self._call_setup_time)
# pylint: enable=E1101
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 LiveSystemSleepResidencyMeasurement(SystemSleepBase):
"""
Sleep mode residency measurement class.
"""
def __init__(self, tc_name, global_config):
"""
Constructor
:type tc_name: BaseConf
:param tc_name: Configuration of the usecase
:type global_config: Dictionary
:param global_config: Global configuration of the campaign
"""
# Call UseCase base constructor
self._device = DeviceManager().get_device("PHONE1")
self.__adbConnectionTimeout = self._device.get_config(
"adbConnectTimeout", 30, float)
self._device_uptime_begin = None
self._sleep_duration = None
# If the device was disconnected before due to an error
# we must reconnect it explicitly at the beginning of the test
# else some commands will not be executed and the test will be blocked
self._system_api = self._device.get_uecmd("System")
return_code = self._system_api.wait_for_device(
self.__adbConnectionTimeout)
if not return_code:
time.sleep(30)
if not self._device.is_available():
self._device.connect_board()
# Call SystemSleepBase base Init function
SystemSleepBase.__init__(self, tc_name, global_config)
self._report_tree = global_config.campaignConfig.get(
"campaignReportTree")
self._sysdebug_apis = self._device.get_uecmd("SysDebug")
self._tc_name = os.path.basename(self.get_name())
self._tc_date = ""
attributes = {"id": self._tc_name, "date": self._tc_date}
self.__results = PnPResults(self._report_tree,
self._dut_config.get("Name"),
self._failure_file, None, attributes)
def run_test(self):
"""
Execute the test
"""
sysdbg_modules_config = self._tc_parameters.get_param_value(
"SYSDEBUG_MODULES")
self._sysdebug_apis.init(sysdbg_modules_config)
sleep_parameter = self._tc_parameters.get_param_value("SLEEP_DURATION")
if sleep_parameter is not None and sleep_parameter != "" and sleep_parameter.isdigit(
):
self._sleep_duration = int(sleep_parameter)
# Call live sleep use case base
SystemSleepBase.run_test(self)
self._tc_date = time.strftime("%Y-%m-%d %H:%M:%S")
self.__results.update({"date": self._tc_date})
while not self._sysdebug_apis.synchronize():
time.sleep(10)
adbConnectTimeout = self._device.get_config("adbConnectTimeout", 10,
float)
usbReplugRetries = self._device.get_config("usbReplugRetries", 1, int)
if self._io_card is not None:
self._device.disconnect_board()
self._sysdebug_apis.reset() # will clear mid_pmu_states
self._residency_api.clear(
self._sleep_duration) # will also clear mid_pmu_states
# but this is needed to do the fetch on this instance
self._io_card.usb_host_pc_connector(False)
# Unplug wall charger only if it is AC_CHGR
if self._device.get_default_wall_charger(
) == self._io_card.AC_CHGR:
self._io_card.wall_charger_connector(False)
# Update device uptime
updated, self._device_uptime_begin = self._device._update_device_up_state(
0)
if not updated:
self._device_uptime_begin = None
if self._sleep_duration:
self._logger.info(
"Wait for %s s before measurement (sleep duration before %s)" %
(str(self._sleep_duration), self._sleep_mode))
time.sleep(self._sleep_duration)
self._sysdebug_apis.start()
self._logger.info("Wait for %s s to enter in %s" %
(str(self._duration), self._sleep_mode))
time.sleep(self._duration)
self._sysdebug_apis.stop()
residency_spent = 0
ret_code = None
if self._io_card is not None:
for cnt in range(0, usbReplugRetries + 1):
self._logger.debug("Loop Iteration: %d" % cnt)
# plug wall charger only if it is AC_CHGR
if self._device.get_default_wall_charger(
) == self._io_card.AC_CHGR:
self._io_card.wall_charger_connector(True)
self._io_card.usb_host_pc_connector(True)
self._logger.debug("Wait for device %s seconds" %
self.__adbConnectionTimeout)
ret_code = self._system_api.wait_for_device(
self.__adbConnectionTimeout)
self._logger.debug("Wait for device return code: %s" %
ret_code)
if not ret_code:
if cnt < usbReplugRetries:
self._logger.warning(
"timeout on wait-for-device, trying to unplug/replug (try %s/%s)"
% (str(cnt + 1), str(usbReplugRetries)))
self._io_card.usb_host_pc_connector(False)
# Unplug wall charger only if it is AC_CHGR
if self._device.get_default_wall_charger(
) == self._io_card.AC_CHGR:
self._io_card.wall_charger_connector(False)
time.sleep(10)
continue
residency_spent = self._residency_api.get_value(
"residency", self._sleep_mode_api.get_sleep_mode())
self._sysdebug_apis.fetch()
self._device.connect_board()
self._logger.debug("device retrieved after %s tries" %
str(cnt + 1))
break
if not ret_code:
raise DeviceException(
DeviceException.OPERATION_FAILED,
"Could not retrieve the device after %s plug/unplug cycles"
% str(usbReplugRetries))
if residency_spent is None:
raise DeviceException(
DeviceException.INVALID_PARAMETER,
"There is no %s sleep mode for this device model" %
self._sleep_mode_api.get_sleep_mode())
# Get device uptime and raise an exception if the device rebooted
if self._device_uptime_begin:
updated, uptime = self._device._update_device_up_state(
self._device_uptime_begin)
if updated and not self._device.is_up:
self._logger.warning(
"the device uptime was %s before the measurement, %s now !"
% (str(self._device_uptime_begin), str(uptime)))
raise DeviceException(
DeviceException.OPERATION_FAILED,
"Device rebooted during the measurement")
sysreport = self._sysdebug_apis.report()
self.__results.append(sysreport)
self.__results.write()
return self._residency_verdict(residency_spent)
class LiveDsdsFtMms(UseCaseBase):
"""
Use Case Live SMS loopback class.
"""
def __init__(self, tc_name, global_config):
UseCaseBase.__init__(self, tc_name, global_config)
self.awake = False
self._test_timeout = 10
self._call_setup_time = 15
self.d = Device(self._device.retrieve_serial_number())
self._registration_timeout = \
int(self._dut_config.get("registrationTimeout"))
self._phone_number = str(self._device.get_phone_number())
self._repeat_count = 0
repeat_count = self._tc_parameters.get_param_value("REPEAT_COUNT", "0")
if repeat_count and repeat_count.isdigit():
self._repeat_count = int(repeat_count)
self._destination_number = \
str(self._tc_parameters.get_param_value("DESTINATION_NUMBER"))
# Retrieve the mms_type parameters.
self._mms_type = self._tc_parameters.get_param_value("MMS_TYPE")
# Retrieve the MMS subject.
self._mms_subject = self._tc_parameters.get_param_value("MMS_SUBJECT")
if self._mms_type == "text":
self._attachment_file = None
else:
self._multimedia_path = self._device.multimedia_path
# Retrieve the path of the MMS attachment.
self._attachment_file = os.path.join(
self._multimedia_path,
self._tc_parameters.get_param_value("ATTACHED_FILE"))
# Retrieve the time that the test should wait to receive the MMS.
self._send_mms_timeout = \
int(self._tc_parameters.get_param_value("SENT_MMS_TIMEOUT"))
self._message=\
str(self._tc_parameters.get_param_value("MESSAGE_CONTENT", ""))
self._received_mms_timeout = \
int(self._tc_parameters.get_param_value("RECEIVED_MMS_TIMEOUT"))
self._test_timeout = 10
self._phone = DeviceManager().get_device("PHONE1")
self._phone2 = DeviceManager().get_device("PHONE2")
self._phone_number2 = str(self._phone2.get_phone_number())
self._default_sim = self._tc_parameters.get_param_value("DEFAULT_SIM")
self._network_pref = self._tc_parameters.get_param_value(
"PREFERRED_NETWORK_TYPE", None)
if self._network_pref:
self._network_pref = self._network_pref.upper()
self._initial_pref_network = None
#Parameter to download or upload
self._direction = self._tc_parameters.get_param_value("DIRECTION")
self._server_name = \
self._tc_parameters.get_param_value("SERVER_NAME",
"LAB_SERVER")
self._callduration = \
int(self._tc_parameters.get_param_value("CALL_DURATION"))
# Get FTP server parameters
self._server = \
global_config.benchConfig.get_parameters(self._server_name)
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 = ""
#The file need to download
self._dlfilename = os.path.join(
self._ftp_path, self._tc_parameters.get_param_value("DL_FILE", ""))
#Max time for file transfer
self._xfer_timeout = \
int(self._tc_parameters.get_param_value("XFER_TIMEOUT"))
# The base name of the file we download
self._ftp_file_basename = self._tc_parameters.get_param_value(
"BASENAME")
self._system_api = self._device.get_uecmd("System")
self._sms_api = self._device.get_uecmd("SmsMessaging")
self._sms_api2 = self._phone2.get_uecmd("SmsMessaging")
self._mms_api = self._device.get_uecmd("MmsMessaging")
self._mms_api2 = self._phone2.get_uecmd("MmsMessaging")
self._sms_api2 = self._phone2.get_uecmd("SmsMessaging")
#self._voice_call_api2 = self._phone2.get_uecmd("VoiceCall")
self._networking_api = self._device.get_uecmd("Networking")
self._phone_system_api = self._device.get_uecmd("PhoneSystem")
#self._phone_system_api2 = self._phone2.get_uecmd("PhoneSystem")
self._ftp_api = self._device.get_uecmd("Ftp")
self._modem_api = self._device.get_uecmd("Modem")
self._phonesystem_api = self._device.get_uecmd("PhoneSystem")
#self._phone_system_api2 = self._phone2.get_uecmd("PhoneSystem")
self._networking_api = self._device.get_uecmd("Networking")
#self._voice_call_api2 = self._phone2.get_uecmd("VoiceCall")
#self._networking_api2 = self._phone2.get_uecmd("Networking")
self._voicecall_api = self._phone.get_uecmd("VoiceCall")
if self._phone2 is not None:
self._voice_call_api2 = self._phone2.get_uecmd("VoiceCall")
self._networking_api2 = self._phone2.get_uecmd("Networking")
self._phone_system_api2 = self._phone2.get_uecmd("PhoneSystem")
#--------------------------------------------------------------------------------------
def set_up(self):
"""
Setup for the test case
"""
# Call set_up of use case base
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 use case requires two phones to be executed !"
self._logger.error(error_msg)
raise AcsConfigException(AcsConfigException.INVALID_BENCH_CONFIG,
error_msg)
# Boot the other phone (the DUT is already booted)
if not self._phone2.is_available():
DeviceManager().boot_device("PHONE2")
if self._default_sim == "SIM2":
#Setting the sim to Default
(verdict, msg) = self._setDefaultSecondSim()
else:
(verdict, msg) = self._setDefaultSim()
time.sleep(10)
self._absolute_path_on_dut = "".join(
[self._device.multimedia_path, self._ftp_file_basename])
# Delete the FTP download file on the DUT
self._delete_file_if_exists(self._absolute_path_on_dut)
# Disable flight mode
self._networking_api.set_flight_mode("off")
time.sleep(self._wait_btwn_cmd)
if self._mms_type.lower() == "picture":
# Checks if the attachment file exist.
self._phonesystem_api.check_file_exist(self._attachment_file)
# Kill the messaging application.
self._kill_messaging_app()
time.sleep(self._wait_btwn_cmd)
# There is a preferred network to set, backup initial, then set configured one
if self._network_pref is not None:
self._initial_pref_network = self._dut_config.get(
"defaultPreferredNetwork")
time.sleep(self._wait_btwn_cmd)
if self._networking_api.is_preferred_network_type_valid(
self._network_pref):
# Setting the DUT preferred network type to the one specified
# in the TC.
self._networking_api.set_preferred_network_type(
self._network_pref)
time.sleep(self._wait_btwn_cmd)
# Check the DUT is camped on a compatible network with the selected
# preferred network.
self._modem_api.check_rat_with_pref_network(
self._network_pref, self._registration_timeout)
time.sleep(self._wait_btwn_cmd)
else:
raise AcsConfigException(
AcsConfigException.INVALID_PARAMETER,
"Unknown network type: %s" % self._network_pref)
return verdict, msg
#--------------------------------------------------------------------------------------
def run_test(self):
"""
Execute the test
"""
#Call UseCase base run function
UseCaseBase.run_test(self)
queue = Queue.Queue()
#creating empty list to append the threads
threads = []
#creating empty list to append the return value from the threads
result = []
try:
#creating thread object to trigger to the _ftpdownloads method
thread_ftp = Thread(target=self._ftpdownload, args=[queue])
thread_ftp.setName("Thread1")
#to start the thread object
thread_ftp.start()
time.sleep(10)
#creating thread object to trigger to the _smssendreceive method
thread_mms = Thread(target=self._sendmms, args=[queue])
thread_mms.setName("Thread2")
#to start the thread object
thread_mms.start()
except Exception as inst:
self._logger.info(inst)
raise AcsConfigException(AcsConfigException.OPERATION_FAILED,
"Exception: %s" % inst)
return Global.FAILURE, "Error"
#appending the thread object into the empty list
threads.append(thread_ftp)
#appending the thread object into the empty list
threads.append(thread_mms)
for thread_id in threads:
#to make the thread wait for the other thread does not complete
thread_id.join()
#appending the return value to the list
result.append(queue.get())
#checking the return value is SUCCESS
if (result[0] or result[1]) == Global.SUCCESS:
return Global.SUCCESS, "SUCCESSFULL"
else:
return Global.FAILURE, "Error"
#---------------------------------------------------------------------------------------------
def _ftpdownload(self, queue):
"""
Execute the web browsing
"""
#creating the lock
lock = threading.Lock()
lock.acquire()
try:
self._logger.info("inside _ftpdownload function")
#Thread no
self._logger.info(current_thread())
#checking the pdp status
pdp_context_status = self._networking_api._get_pdp_context_status()
if pdp_context_status in ("0", "2"):
self._networking_api.activate_pdp_context()
time.sleep(self._wait_btwn_cmd)
if self._direction == "DL":
self._logger.info("FTP transfer " + str(self._direction) +
" for " + str(self._dlfilename) + "...")
# Uecmd to do ftp and storing the result
result = self._networking_api.\
ftp_xfer(self._uecmd_types.XFER_DIRECTIONS.DL, # pylint: disable=E1101
self._server_ip_address,
self._username,
self._password,
self._dlfilename,
self._xfer_timeout,
self._device.multimedia_path)
else:
self._error.Code = Global.FAILURE
self._error.Msg = "%s is not a known xfer direction" % self._direction
self._logger.info(self._error.Msg)
queue.put(self._error.Code)
except Exception as inst:
self._error.Code = Global.FAILURE
queue.put(self._error.Code)
self._logger.info(inst)
raise AcsConfigException(AcsConfigException.OPERATION_FAILED,
"Exception : %s" % inst)
finally:
#lock is released
lock.release()
self.awake = True
#giving the return value into queue
queue.put(Global.SUCCESS)
#---------------------------------------------------------------------------------------------
def _sendmms(self, queue):
lock = threading.Lock()
lock.acquire()
try:
time_to_receive_mms = None
time_to_send_mms = None
time_waited = 0
# Max number of iteration done while waiting for the screen to turn off.
# Used to prevent endless loops.
max_time_waited = 200
# Clear all SMS and MMS.
self._mms_api.delete_all_messages()
# Wait for the screen to turn off.
while self._phonesystem_api.get_screen_status() \
and time_waited < max_time_waited:
time.sleep(5)
time_waited += 5
self._logger.info("Waited %s seconds for the screen to turn off." %
time_waited)
# Checks if the screen turned off before a fixed timeout.
if time_waited >= max_time_waited:
raise DeviceException(
DeviceException.TIMEOUT_REACHED,
"The screen did not turned off in %s." % max_time_waited)
# Wake up the phone screen.
time.sleep(self._wait_btwn_cmd)
self._logger.info("Turning the screen on.")
self._phonesystem_api.set_phone_lock("off")
self._phonesystem_api.wake_screen()
self._phonesystem_api.set_phone_lock(0)
# register on intent to receive incoming mms
self._mms_api2.register_for_mms_reception()
# Build the MMS.
time.sleep(self._wait_btwn_cmd)
self._mms_api.send_mms(self._mms_type, self._destination_number,
self._mms_subject, self._message,
self._attachment_file, self._repeat_count)
time.sleep(self._wait_btwn_cmd)
# Waiting for the MMS to be send.
sent_time = self._mms_api.check_mms_sent(self._destination_number,
self._send_mms_timeout)
# Waiting on incoming message.
reception_date = self._mms_api2.wait_for_incoming_mms(
self._received_mms_timeout, self._destination_number)
# Logging the time taken to receive the MMS.
time_to_receive_mms = float(reception_date) - float(sent_time)
self._logger.info("The MMS has been received in %s seconds." %
time_to_receive_mms)
# Compare the sent and received MMS.
self._mms_api.request_remote_send_received_mms_compare(
self._mms_type)
except Exception as inst:
self._error.Code = Global.FAILURE
queue.put(self._error.Code)
self._logger.info(inst)
raise AcsConfigException(AcsConfigException.OPERATION_FAILED,
"Exception : %s" % inst)
finally:
#lock is released
lock.release()
print("the awake for ftp")
print(self.awake)
queue.put(Global.SUCCESS)
#--------------------------------------------------------------------------------------------------
def _setDefaultSim(self):
self._device.run_cmd("adb shell input keyevent 82",
self._test_timeout,
force_execution=True)
time.sleep(8)
#To pop up the dialog box for selecting the sim
statusintent = self._voicecall_api.get_sim_select(dialog=3, sim=0)
self._logger.info(statusintent)
#To check dailog is reached or not
if statusintent == {}:
err_msg = " The option dialog is not reached"
raise DeviceException(DeviceException.OPERATION_SET_ERROR, err_msg)
return Global.FAILURE, err_msg
#Waiting for the dailog box
if self.d(resourceId='android:id/title_template').wait.exists(
timeout=5000):
#clicking the default sim
self.d(resourceId='android:id/button1').click()
self._logger.info("Default sim is selected")
return Global.SUCCESS, "Default sim is selected"
else:
err_msg = "Dialog is not opening"
raise DeviceException(DeviceException.OPERATION_SET_ERROR, err_msg)
return Global.FAILURE, err_msg
#-------------------------------------------------------------------------------------------------
def _setDefaultSecondSim(self):
self._device.run_cmd("adb shell input keyevent 82",
self._test_timeout,
force_execution=True)
time.sleep(8)
#To pop up the dialog box for selecting the sim
statusintent = self._voicecall_api.get_sim_select(dialog=3, sim=1)
self._logger.info(statusintent)
#To check dailog is reached or not
if statusintent == {}:
err_msg = " The option dialog is not reached"
raise DeviceException(DeviceException.OPERATION_SET_ERROR, err_msg)
return Global.FAILURE, err_msg
#Waiting for the dailog box
if self.d(resourceId='android:id/title_template').wait.exists(
timeout=5000):
#clicking the default sim
self.d(resourceId='android:id/button1').click()
self._logger.info("Default sim is selected")
return Global.SUCCESS, "Default sim is selected"
else:
err_msg = "Dialog is not opening"
raise DeviceException(DeviceException.OPERATION_SET_ERROR, err_msg)
return Global.FAILURE, err_msg
#-------------------------------------------------------------------------------------------------
def _delete_file_if_exists(self, file_path, fail_on_error=True):
"""
Deletes the given file on DUT if it exists.
:type file_path: str
:param file_path: the absolute path of the file to delete.
:type fail_on_error: bool
:param fail_on_error: [optional] a boolean indicating whether
we want to raise an exception on error or not.
Defaults to C{True}.
"""
# Force file path to a str value
file_path = str(file_path)
rm_cmd = "adb shell rm %s" % file_path
# We go on only if the file exists on the DUT
if not self._phone_system_api.check_file_exist_from_shell(file_path):
self._logger.debug("No such file to delete.")
return
# We try to delete the file
try:
# Run the command to remove the file, we give it 10 seconds to run
self._logger.debug("Deleting file %s." % file_path)
(exit_status, _output) = internal_shell_exec(rm_cmd, 10)
except (KeyboardInterrupt, SystemExit):
raise
# We want to trap any kind of error/exception so
# we use an empty exception clause and disable the
# corresponding Pylint warning.
# pylint: disable=W0702
except:
exit_status = Global.FAILURE
traceback.print_exc()
# Check the status of the command execution
if exit_status != Global.SUCCESS:
# Build an error message
error_message = "Command execution failed (command: '%s')." % rm_cmd
# Handle the error case as expected
if fail_on_error:
# If we have to fail, raise an exception
raise DeviceException(DeviceException.OPERATION_FAILED,
error_message)
else:
# Otherwise simply log a warning
self._logger.warning(error_message)
# We double-check that the file has been deleted
if self._phone_system_api.check_file_exist_from_shell(file_path):
# Build an error message
error_message = "File deletion failed (file: '%s')." % file_path
# Handle the error case as expected
if fail_on_error:
# If we have to fail, raise an exception
raise DeviceException(DeviceException.OPERATION_FAILED,
error_message)
else:
# Otherwise simply log a warning
self._logger.warning(error_message)
else:
self._logger.info("File %s deleted successfully." % file_path)
#--------------------------------------------------------------------------------
def _kill_messaging_app(self):
"""
Kills the MMS application if it was running and makes sure it has been
killed successfully
"""
# Get the pid of the MMS application
pid = self._system_api.pid_of("com.android.mms")
# Killing the MMS application, if running
if pid != "":
self._mms_api.kill_mms_app()
# Checking if the MMS application as really been killed.
new_pid = self._system_api.pid_of("com.android.mms")
if new_pid == pid:
raise DeviceException(
DeviceException.OPERATION_FAILED,
"The stock messaging application"
" should not be running.")
else:
self._logger.info("The MMS application was not running.")
class LabNfcDualPhoneBeamTransfert(LabNfcBase):
# the name of ref phone is the name in BENCH_CONFIG file
REF_PHONE = "PHONE2"
def __init__(self, tc_name, global_config):
LabNfcBase.__init__(self, tc_name, global_config)
# second phone init
self._phone_ref = DeviceManager().get_device(
LabNfcDualPhoneBeamTransfert.REF_PHONE)
self._phone_ref.connect_board()
# Check if we have the ref phone available
if self._phone_ref is not None:
if not self._phone_ref.is_available():
DeviceManager().boot_device(
LabNfcDualPhoneBeamTransfert.REF_PHONE)
self._nfc_api_phone_ref = self._phone_ref.get_uecmd(
"LocalConnectivity")
# get PhoneSystem uecmd instance for the ref phone
self._phonesystem_api_dut = self._device.get_uecmd("PhoneSystem")
self._phonesystem_api_ref = self._phone_ref.get_uecmd("PhoneSystem")
self._appmgmt_api = self._phone_ref.get_uecmd("AppMgmt")
# get file uecmd instance
self._file_api_dut = self._device.get_uecmd("File")
self._file_api_ref = self._phone_ref.get_uecmd("File")
# Get NFC Tags application package name
self._tag_app = str(self._dut_config.get("TagsAppPackageName"))
# Get Browsers application package name (need to disable in order to be able to read URI tags)
self._browser_app = str(self._dut_config.get("BrowserAppPackageName"))
self._chrome_app = str(self._dut_config.get("ChromeAppPackageName"))
# force phone 2 state unlock and display on
# for the DUT this is made in LiveNfcBase class
self._phonesystem_api_ref.display_on()
self._phonesystem_api_ref.set_phone_lock(0)
self._nfc_api_phone_ref.force_nfc_state(1)
# BE careful here we have to be sure that the file is here (setup embbeded)
self.__file_to_share = str(
self._tc_parameters.get_param_value("FILE_TO_SHARE"))
self.__beam_duration = int(
self._tc_parameters.get_param_value("BEAM_DURATION"))
self.__direction = str(
self._tc_parameters.get_param_value("DIRECTION")).upper()
self._nfc_robot_param = global_config.benchConfig.get_parameters(
"NFC_ROBOT1")
self._beam_path = self._tc_parameters.get_param_value("BEAM_PATH")
# get ref phone position
self.__ref_phone_position = self._tc_parameters.get_param_value(
"REF_PHONE_POSITION")
self._tag_up = self._nfc_robot_param.get_param_value(
self.__ref_phone_position + "Up")
self._tag_down = self._nfc_robot_param.get_param_value(
self.__ref_phone_position + "Down")
self._tag_X = self._nfc_robot_param.get_param_value(
self.__ref_phone_position + "X")
# get the antenna position
antenna_position = self._device.get_config("NfcAntennaPosition")
self._tag_Y = str(
int(
self._nfc_robot_param.get_param_value(
self.__ref_phone_position + "Y")) +
int(antenna_position.split(",")[1]))
# ----------------------------------------------------------------------------------------------
def set_up(self):
LabNfcBase.set_up(self)
# dont need to check if BEAM activated because of the parameters
# self._Device is DUT
# self._phone_ref is the reference phone
# disable "Tags" and browsers built-in apps
# In DUT
self._appmgmt_api.app_enable_disable(self._tag_app, False)
self._appmgmt_api.app_enable_disable(self._browser_app, False)
self._appmgmt_api.app_enable_disable(self._chrome_app, False)
# in phone ref
self._appmgmt_api.app_enable_disable(self._tag_app, False)
self._appmgmt_api.app_enable_disable(self._browser_app, False)
self._appmgmt_api.app_enable_disable(self._chrome_app, False)
self.__size_of_file = 0
# file have to be in both device, and get its size
file_exist, result = self._file_api_dut.exist(
posixpath.join(self._device.multimedia_path, self.__file_to_share))
if file_exist:
size = self._file_api_dut.size(
posixpath.join(self._device.multimedia_path,
self.__file_to_share))
self.__size_of_file = size
else:
msg = "File to transfert missing on DUT "
raise AcsConfigException(AcsConfigException.FILE_NOT_FOUND, msg)
size = 0
file_exist, result = self._file_api_ref.exist(
posixpath.join(self._device.multimedia_path, self.__file_to_share))
if file_exist:
size = self._file_api_ref.size(
posixpath.join(self._device.multimedia_path,
self.__file_to_share))
if size != self.__size_of_file:
msg = "File to share are different size on DUT and reference phone"
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
msg)
else:
msg = "File to transfert missing on reference phone "
raise AcsConfigException(AcsConfigException.FILE_NOT_FOUND, msg)
return Global.SUCCESS, "No errors"
# ----------------------------------------------------------------------------------------------
def run_test(self):
msg = "No errors"
# move robot to start position
self._robot_positioning(self._tag_X, self._tag_Y, self._tag_up, 'null')
# do the DUT to ref phone transfert
if "SEND" or "FULL" in self.__direction:
# starting beam sequence with DUT
self.__beam_sequence(self._device)
if not self.__is_transfert_ok(self._file_api_ref):
msg = "Error : send BEAM failed on %s sequence" % self.__direction
# clear beamed files
self.__clear_beam_sequence()
time.sleep(5)
# do the ref phone to DUT transfert
if "RECEIVE" or "FULL" in self.__direction:
# starting beam sequence with phone ref
self.__beam_sequence(self._phone_ref)
if not self.__is_transfert_ok(self._file_api_dut):
msg += "Error : receive BEAM failed on %s sequence" % self.__direction
# clear beamed files
self.__clear_beam_sequence()
if msg != "No errors":
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
return Global.SUCCESS, msg
# ----------------------------------------------------------------------------------------------
def tear_down(self):
# move robot to start position
self._robot_positioning(self._tag_X, self._tag_Y, self._tag_up, 'null')
LabNfcBase.tear_down(self)
return Global.SUCCESS, "No errors"
# ----------------------------------------------------------------------------------------------
def __is_transfert_ok(self, device_system_api):
file_exist, result = device_system_api.exist(
posixpath.join(self._beam_path, self.__file_to_share))
if file_exist:
size = device_system_api.size(
posixpath.join(self._beam_path, self.__file_to_share))
if size == self.__size_of_file:
return True
else:
return False
# ----------------------------------------------------------------------------------------------
def __clear_beam_sequence(self):
# clear beamed files on both devices
self._file_api_dut.delete(
posixpath.join(self._beam_path, self.__file_to_share))
self._file_api_ref.delete(
posixpath.join(self._beam_path, self.__file_to_share))
return True
# ----------------------------------------------------------------------------------------------
def __open_image(self, device, file_to_open):
cmd = "adb shell am start -d file:%s -t image/* -a android.intent.action.VIEW -n com.google.android.gallery3d/com.android.gallery3d.app.GalleryActivity" % str(
file_to_open)
device.run_cmd(cmd, 10)
return True
# ----------------------------------------------------------------------------------------------
def __close_image(self, device):
# close image
cmd = "adb shell pm clear com.google.android.gallery3d"
device.run_cmd(cmd, 10)
time.sleep(1)
return True
# ----------------------------------------------------------------------------------------------
def __beam_sequence(self, beamer):
# first open photo on the beamer
# DEBUG try to use an uecmd instead like start_display_image
self._logger.info("Start to BEAM")
self.__open_image(
beamer, posixpath.join(beamer.multimedia_path,
self.__file_to_share))
# move nfc bot
self._robot_positioning('null', 'null', self._tag_down, 'null')
# wait a while
time.sleep(2)
if beamer.get_config("device_name") == "PHONE1":
res = self._phonesystem_api_dut.get_screen_resolution().split("x")
mres = "%dx%d" % (int(res[0]) / 2, int(res[1]) / 2)
self._nfc_api.nfc_touch_to_beam(mres, 1)
else:
res = self._phonesystem_api_ref.get_screen_resolution().split("x")
mres = "%dx%d" % (int(res[0]) / 2, int(res[1]) / 2)
self._nfc_api_phone_ref.nfc_touch_to_beam(mres, 1)
time.sleep(2)
self._robot_positioning('null', 'null', self._tag_up, 'null')
time.sleep(self.__beam_duration)
# close gallery application
self.__close_image(beamer)
class LiveDualPhoneVcRingToneVibra(UseCaseBase):
"""
Live Voice Call Ring Tone Vibra.
"""
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call init of use case base
UseCaseBase.__init__(self, tc_name, global_config)
# Get Test Cases Parameters
self.__minimum_variation = float(
self._tc_parameters.get_param_value("MINIMUM_VARIATION"))
# Read callSetupTimeout from Phone_Catalog.xml
self.__call_setup_time = int(self._dut_config.get("callSetupTimeout"))
# Get UECmdLayer
self.__voice_call_api = self._device.get_uecmd("VoiceCall")
self.__networking_api = self._device.get_uecmd("Networking")
self.__sensor_api = self._device.get_uecmd("Sensor")
self.__system_api = self._device.get_uecmd("System")
# Load instance of the PHONE2
self.__phone2 = DeviceManager().get_device("PHONE2")
if self.__phone2 is not None:
self.__voice_call_api2 = self.__phone2.get_uecmd("VoiceCall")
self.__networking_api2 = self.__phone2.get_uecmd("Networking")
else:
self.__voice_call_api2 = None
self.__networking_api2 = None
# Get phone1 number
self.__phone_number = str(self._device.get_phone_number())
# Instantiate the instances for phone caller, receiver and releaser
self.__caller_phone = self.__voice_call_api2
self.__receiver_phone = self.__voice_call_api
self.__releaser_phone = self.__voice_call_api2
self.__check_accelerometer_time = 5
self.__wait_btw_accelerometer_check = 0.5
#------------------------------------------------------------------------------
def set_up(self):
"""
Initialize the test
"""
# Call set_up of use case base
UseCaseBase.set_up(self)
if not self.__minimum_variation or self.__minimum_variation <= 0.5:
self.__minimum_variation = 0.5
# 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 use case requires two phones to be executed !"
self._logger.error(error_msg)
raise AcsConfigException(AcsConfigException.INVALID_BENCH_CONFIG,
error_msg)
# Boot the other phone (the DUT is already booted)
if not self.__phone2.is_available():
DeviceManager().boot_device("PHONE2")
# Disable flight mode
self.__networking_api.set_flight_mode("off")
self.__networking_api2.set_flight_mode("off")
# Phone1: set Ringtone volume to 0%, will be in vibration mode
self.__system_api.adjust_specified_stream_volume('Ringtone', 0)
return Global.SUCCESS, "No errors"
#------------------------------------------------------------------------------
def run_test(self):
"""
Execute the test
"""
verdict = Global.SUCCESS
msg = "No errors"
# Call init of use case base
UseCaseBase.run_test(self)
# Release any previous call (Robustness)
time.sleep(self._wait_btwn_cmd)
self.__voice_call_api.release()
self.__voice_call_api2.release()
# PHONE1: Check accelerometer return before the call
output, x, y, z = self.__sensor_api.check_sensor_info(
"accelerometer", "data", "reserve")
time.sleep(self._wait_btwn_cmd)
initial_accelerometer_value = abs(x) + abs(y) + abs(z)
# ESTABLISH THE CALL
# Phone2 : Dial
time.sleep(self._wait_btwn_cmd)
self.__caller_phone.dial(self.__phone_number, False)
# Phone1 : Wait for state incoming before callSetupTimeout seconds
self.__receiver_phone.wait_for_state(
self._uecmd_types.VOICE_CALL_STATE.INCOMING,
self.__call_setup_time)
# PHONE1: Check accelerometer return during the call
accelerometer_value_while_voice_call = 0
for iteration in range(self.__check_accelerometer_time):
output, x, y, z = self.__sensor_api.check_sensor_info(
"accelerometer", "data", "reserve")
# Store the highest accelerometer value
if accelerometer_value_while_voice_call < abs(x) + abs(y) + abs(z):
accelerometer_value_while_voice_call = abs(x) + abs(y) + abs(z)
time.sleep(self.__wait_btw_accelerometer_check)
if accelerometer_value_while_voice_call < initial_accelerometer_value + self.__minimum_variation:
verdict = Global.FAILURE
msg = "Accelerometer value during voice call: %s, is not as expected, should be >= %s " \
% (str(accelerometer_value_while_voice_call), \
str(initial_accelerometer_value + self.__minimum_variation))
# RELEASE THE CALL
# Phone2 : Release the call
time.sleep(self._wait_btwn_cmd)
self.__releaser_phone.release()
# Phone1 & 2 : Check call is idle
self.__voice_call_api.wait_for_state(
self._uecmd_types.VOICE_CALL_STATE.NOCALL, self.__call_setup_time)
self.__voice_call_api2.wait_for_state(
self._uecmd_types.VOICE_CALL_STATE.NOCALL, self.__call_setup_time)
return verdict, msg
def tear_down(self):
"""
tear down
"""
UseCaseBase.tear_down(self)
# Phone1: set Ringtone volume to 50%
self.__system_api.adjust_specified_stream_volume('Ringtone', 50)
return self._error.Code, "No errors"
class LabWifiDirectBase(UseCaseBase):
"""
Lab Wifi Direct class.
"""
DEFAULT_REGULATORY_DOMAIN = "US"
def __init__(self, tc_name, global_config):
"""
Constructor
"""
UseCaseBase.__init__(self, tc_name, global_config)
self._device1_name = self._tc_parameters.get_param_value(
"DEVICE1_NAME", "")
self._device2_name = self._tc_parameters.get_param_value(
"DEVICE2_NAME", "")
# Get P2p interface name
self._device1_p2pinterface = str(self._dut_config.get("p2pInterface"))
self._device1_supplicant = None
self._device1_client = None
self._device1_mac = None
self._device2_supplicant = None
self._device2_client = None
self._device2_mac = None
self._phone2 = None
self._networking2_api = None
self._device2_p2pinterface = None
if self._device2_name.startswith("PHONE"):
self.dut_config2 = DeviceManager().get_device_config("PHONE2")
self._device2_p2pinterface = str(
self.dut_config2.get("p2pInterface"))
# Get Device 2 Instance
self._phone2 = DeviceManager().get_device(self._device2_name)
self._networking2_api = self._phone2.get_uecmd("Networking")
self._networking_api = self._device.get_uecmd("Networking")
self._dut1_wlan_iface = str(self._dut_config.get("wlanInterface"))
self._dut2_wlan_iface = str(self.dut_config2.get("wlanInterface"))
def set_up(self):
"""
Initialize the test
"""
UseCaseBase.set_up(self)
self.__check_tc_parameters()
if self._phone2 is not None and not self._phone2.is_available():
DeviceManager().boot_device(self._device2_name)
# set wifi On on the DUT to allow regulatory domain to change
self._networking_api.set_wifi_power("on")
if self._networking2_api is not None:
self._networking2_api.set_wifi_power("on")
# set the regulatory domain
self._networking_api.set_regulatorydomain(
LabWifiDirectBase.DEFAULT_REGULATORY_DOMAIN, self._dut1_wlan_iface)
if self._networking2_api is not None:
self._networking2_api.set_regulatorydomain(
LabWifiDirectBase.DEFAULT_REGULATORY_DOMAIN,
self._dut2_wlan_iface)
# set wifi Off on the DUT
self._networking_api.set_wifi_power("off")
if self._networking2_api is not None:
self._networking2_api.set_wifi_power("off")
return Global.SUCCESS, "No error"
#------------------------------------------------------------------------------
def _get_supplicant_instance(self, device_name):
"""
Get the p2p supplicant instance for the device
:rtype: UECmd Object or Equipement Object
:return: The p2p supplicant instance for the device
"""
device_instance = self.__get_device_instance(device_name)
if device_name.startswith("PHONE"):
return device_instance.get_uecmd("P2PSupplicantCLI")
if device_name.startswith("COMPUTER"):
return device_instance.get_p2p("P2pSupplicant")
msg = "device not found " + device_name
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
def _get_client_instance(self, device_name):
"""
return the p2p client instance for the device
"""
device_instance = self.__get_device_instance(device_name)
if device_name.startswith("PHONE"):
return device_instance.get_uecmd("P2PClientCLI")
if device_name.startswith("COMPUTER"):
return device_instance.get_p2p("P2pClient")
msg = "device not found " + device_name
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
def __get_device_instance(self, device_name):
"""
retrieve the device instance
"""
if device_name.startswith("COMPUTER"):
return self._em
if device_name == "PHONE1":
return self._device
if device_name.startswith("PHONE"):
if not self._phone2.is_available():
DeviceManager().boot_device(device_name)
return self._phone2
msg = "device not found " + device_name
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
def __check_tc_parameters(self):
"""
Checks all TC parameters
"""
if not self._device1_name:
msg = "undefined device name 1."
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
if not self._device2_name:
msg = "undefined device name 2."
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)