def run_test(self):
"""
As of right now, at the beginning of the RUN part, we have connected the 2 phones in
a PAN-NAP way and we are also connected to the internet.
"""
LiveDualPhoneBTBase.run_test(self)
wifi_router = self.__global_config.benchConfig.get_parameters(self._wifi_access_point)
server_to_ping = wifi_router.get_param_value("IP")
#ping the AP
packet_loss = self._panu_net_api.ping(server_to_ping,
self._packet_size,
self._packet_count)
msg = "Measured Packet Loss: {0} {1} (Target: {2} {3})".format(packet_loss.value, packet_loss.units,
self._target_packet_loss_rate, packet_loss.units)
self._logger.info(msg)
if packet_loss.value > self._target_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)
return (Global.SUCCESS,
"BT Tethering ping %s OK" % str(server_to_ping))
def run_test(self):
"""
Execute the test
"""
# Call UseCase base run_test function
LiveDualPhoneBTBase.run_test(self)
time.sleep(self._wait_btwn_cmd)
# start to browse device
self._logger.info("Service Browsing")
(result, remote) = self._initiator_api.bt_service_browsing(
self._responder_addr)
if self._class_list is "":
if not result:
msg = "Service browsing failed"
self._logger.error(msg)
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
else:
classlist = self._class_list.strip().split(";")
for curr_class in classlist:
# Remove leading and trailing whitespace
curr_class = curr_class.strip()
# Search service class in the list
if BtServiceClass.BT_SERVICE_CLASS[
curr_class] not in remote.uuids:
msg = "Service %s is not found" % curr_class
self._logger.error(msg)
raise DeviceException(DeviceException.OPERATION_FAILED,
msg)
return Global.SUCCESS, "No errors"
def __init__(self, tc_name, global_config):
"""
Constructor
"""
LiveDualPhoneBTBase.__init__(self, tc_name, global_config)
#Get TC parameters
#wifi activity is set to WIFI_WEB_BROWSING for all PAN/NAP/PANU tests
self._wifi_activity = str(self._tc_parameters.get_param_value("WIFI_ACTIVITY")).upper()
if self._wifi_activity == "WIFI_WEB_BROWSING":
self._wifi_url = str(self._tc_parameters.get_param_value("URL_TO_BROWSE"))
self._thread_wifi_activity = None
self._wifi_access_point = str(self._tc_parameters.get_param_value("WIFI_ACCESS_POINT", ""))
# Read DUT_STATE from test case xml file: server or client
self._dut_state = str(self._tc_parameters.get_param_value("DUT_STATE")).upper()
# Read OPP_LOCAL_FILE from test case xml file
self._opp_local_file = str(self._tc_parameters.get_param_value("OPP_LOCAL_FILE"))
self._nap_or_pan_test = str(self._tc_parameters.get_param_value("NAP_OR_PAN_TEST")).upper()
self._connection_to_share = str(self._tc_parameters.get_param_value("CONNECTION_TO_SHARE")).upper()
self._pairing_initiator = str(self._tc_parameters.get_param_value("PAIRING_INITIATOR")).upper()
self._bt_tethering_deactivation_test = \
str(self._tc_parameters.get_param_value("ENABLE_BT_TETHERING_DEACTIVATION_TEST", default_value=False))
self._who_disconnect = str(self._tc_parameters.get_param_value("WHO_DISCONNECT", default_value="NAP")).upper()
self._fail_if = self._tc_parameters.get_param_value("PAIRING_CHECK_FAIL_IF", default_value="disconnected")
self._interleave_search = self._tc_parameters.get_param_value("IS_INTERLEAVE_SEARCH", default_value=False)
self._browse_retries = 2
# Initialize data
self._thread_opp_transfer = None
self._thread_scan_bt = None
self._thread_scan_wifi = None
self._thread_connect_to_nap = None
self._nap_api = None
self._panu_api = None
self._nap_addr = None
self._panu_addr = None
self._wifi_api = None
self._panu_net_api = None
self._paired_api = None
self._pair_requester_api = None
self._queue = Queue.Queue()
self.__global_config = global_config
self._wait_btwn_cmd = 5.0
self._duration = 60
self._replyval = True
self._accept_connection = True
self._must_find = True
self._status = None
self._sleep_time = self._SLEEP_TIME_SECS
self._start_time = None
self._timeout = self._DEFAULT_TIMEOUT_SECS
self._bluetooth_connectivity_obj = BluetoothConnectivity(self._device, self._wait_btwn_cmd)
def set_up(self):
"""
Initialize the test
"""
LiveDualPhoneBTBase.set_up(self)
if self._initiator.strip().lower() in "phone1":
self._initiator_api = self._bt_api
self._responder_addr = self._phone2_addr
self._responder_config = self._dut2_config
elif self._initiator.strip().lower() in "phone2":
self._initiator_api = self._bt_api2
self._responder_addr = self._phone1_addr
self._responder_config = self._dut_config
else:
msg = "Initiator value <%s> is not valid" % self._initiator
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
if self._class_list.upper().strip() == "__USE_DEVICE_SERVICE_LIST__":
# Get default supported service list from device catalog file
# Take value of responder device
self._class_list = str(
self._responder_config.get("SupportedServiceList"))
# Start a first BT scan on initiator to list visible remote
self._initiator_api.bt_scan_devices()
return Global.SUCCESS, "No errors"
def tear_down(self):
#disconnect tethering
self._bluetooth_connectivity_obj.disconnect_bt_tethering_and_pan(self._bt_tethering_deactivation_test, self._nap_api, self._who_disconnect, self._panu_api, self._nap_addr, self._panu_addr)
# Bluetooth unpairing
self._logger.info("Unpair both devices")
paired = False
list_paired_devices = self._panu_api.list_paired_device()
for element in list_paired_devices:
if str(element.address).upper() == str(self._phone2_addr).upper():
paired = True
if paired:
self._bt_api.unpair_bt_device(self._phone2_addr)
self._bt_api2.unpair_bt_device(self._phone1_addr)
else:
pass
# Disconnect and clear WiFi networks
if self._connection_to_share == "WIFI":
self._wifi_api.wifi_remove_config("all")
self._wifi_api.set_wifi_power("off")
LiveDualPhoneBTBase.tear_down(self)
result, output = Global.SUCCESS, ""
return result, output
def run_test(self):
"""
Execute the test
"""
# Call UseCase base run_test function
LiveDualPhoneBTBase.run_test(self)
# Configure BT OPP Transfer thread
# Files used are big, use bigger timeout than default
opp_timeout = 300 + self._duration
if self._dut_state == "DUT_CLIENT":
self._thread_opp_transfer = ThreadOPPTransferFile(
self._queue, self._device, self._phone2, self._opp_local_file,
self._device.multimedia_path, 1, 0, opp_timeout)
else:
self._thread_opp_transfer = ThreadOPPTransferFile(
self._queue, self._phone2, self._device, self._opp_local_file,
self._phone2.multimedia_path, 1, 0, opp_timeout)
# Configure Pair/Unpair activity thread
self._thread_headset_activity = ThreadPairConnectA2DPHeadset(
self._queue, self._duration, self._bt_api,
self._em.get_bluetooth_headset("BT_HEADSET"))
# Launch threads
self._thread_opp_transfer.start()
time.sleep(LabDualPhoneBTOppWithA2DPConnect.WAIT_A2DP_ACTIVITY)
self._thread_headset_activity.start()
time.sleep(self._wait_btwn_cmd)
self._exception_reader(
self._queue,
[self._thread_opp_transfer, self._thread_headset_activity])
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Initialize the test
"""
LiveDualPhoneBTBase.set_up(self)
opp_init_configure(self._device, self._phone2)
time.sleep(self._wait_btwn_cmd)
if self._component_use not in [
"USE_WIFI", "USE_BT", "USE_BT_AND_WIFI"
]:
msg = "COMPONENT_USE parameter unknown - must be USE_WIFI, USE_BT or USE_BT_AND_WIFI"
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
if self._dut_state not in ["DUT_CLIENT", "DUT_SERVER"]:
msg = "DUT state configuration unknown - DUT should be client or server"
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
# WiFi configure if needed
if self._component_use in ["USE_WIFI", "USE_BT_AND_WIFI"]:
if self._ssid in (None, ""):
msg = str(self._ssid) + ": WiFi SSID is missing"
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
msg)
self._networking_api.set_wifi_power(1)
return Global.SUCCESS, "No errors"
def run_test(self):
"""
As of right now, at the beginning of the RUN part, we have connected the 2 phones in
a PAN-NAP way and we are also connected to the internet.
"""
LiveDualPhoneBTBase.run_test(self)
# Configure Wifi Browse threads
if self._wifi_activity == "WIFI_WEB_BROWSING":
self._thread_wifi_activity = ThreadBrowseWifiChrome(self._queue, self._panu_net_api, self._duration, self._browse_retries, self._wifi_url)
else:
msg = "Unknown WIFI_ACTIVITY : %s" % self._wifi_activity
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
# Configure BT OPP Transfer
if self._dut_state == "DUT_SERVER":
self._thread_opp_transfer = ThreadOPPTransferFile(self._queue, self._device, self._phone2,
self._opp_local_file, self._device.multimedia_path, initialize=True)
elif self._dut_state == "DUT_CLIENT":
self._thread_opp_transfer = ThreadOPPTransferFile(self._queue, self._phone2, self._device,
self._opp_local_file, self._phone2.multimedia_path)
self._thread_opp_transfer.start()
time.sleep(20)
self._thread_wifi_activity.start()
time.sleep(self._wait_btwn_cmd)
self._thread_opp_transfer.join()
# This function waits all threads are dead or timeout is over before finish
self._exception_reader(self._queue, [self._thread_wifi_activity, self._thread_opp_transfer])
result, output = Global.SUCCESS, ""
return result, output
def set_up(self):
"""
Initialize the test
"""
LiveDualPhoneBTBase.set_up(self)
# defines NAP / PAN-User roles
if self._nap_or_pan_test == "NAP":
self._nap_api = self._bt_api
self._nap_addr = self._phone1_addr
self._panu_api = self._bt_api2
self._panu_addr = self._phone2_addr
self._wifi_api = self._networking_api
self._panu_net_api = self._networking_api2
elif self._nap_or_pan_test == "PAN":
self._nap_api = self._bt_api2
self._nap_addr = self._phone2_addr
self._panu_api = self._bt_api
self._panu_addr = self._phone1_addr
self._wifi_api = self._networking_api2
self._panu_net_api = self._networking_api
else:
raise AcsConfigException(AcsConfigException.INVALID_TEST_CASE_FILE, "You did not provide a valid value for the NAP_OR_PAN_TEST parameter. It must pe NAP or PAN.")
# Handle External connection (WIFI or CELLULAR)
self._bluetooth_connectivity_obj.handle_external_connection(self._connection_to_share, self._wifi_api, self.__global_config, self._wifi_access_point)
time.sleep(self._wait_btwn_cmd)
#initialize phone for PAN
if self._interleave_search is False:
self._bluetooth_connectivity_obj.search_for_device_until_found(self._panu_api, self._nap_api, self._nap_addr, self._must_find)
elif self._interleave_search is True:
self._bluetooth_connectivity_obj.search_for_device_interleave(self._panu_api, self._nap_api, self._nap_addr, self._must_find)
# Pair the DUT with the device
self._bluetooth_connectivity_obj.try_until_paired(self._panu_api, self._nap_api, self._panu_addr, self._nap_addr, self._replyval, self._accept_connection)
# # 4) Set tethering power to on, PAN connect
# PAN connect the devices
# Enable BT tethering
#check devices are truly paired
self._bluetooth_connectivity_obj.check_paired(self._panu_api, self._nap_addr)
self._nap_api.set_bt_tethering_power("on")
time.sleep(self._wait_btwn_cmd)
#connect PAN way
self._panu_api.connect_bt_device(self._nap_addr, BtProfile.PAN)
#check profiles are connected
keep_going = True
self._start_time = time.time()
while keep_going:
self._status = self._panu_api.get_bt_connection_state(self._nap_addr, BtProfile.PAN)
keep_going = self._bluetooth_connectivity_obj._keep_going(self._status, self._start_time, self._timeout)
self._bluetooth_connectivity_obj._raise_error_if_fail_when_profiles_not_connected(self._status, self._fail_if)
result, output = Global.SUCCESS, ""
return result, output
def run_test(self):
"""
Execute the test
"""
# pylint: disable=E1101
# Call UseCase base run_test function
LiveDualPhoneBTBase.run_test(self)
# Configure BT OPP Transfer
if self._dut_state == "DUT_CLIENT":
self._thread_opp_transfer = ThreadOPPTransferFile(
self._queue, self._device, self._phone2, self._opp_local_file,
self._device.multimedia_path)
self._thread_opp_transfer_retry = ThreadOPPTransferFile(
self._queue, self._device, self._phone2, self._opp_local_file,
self._device.multimedia_path)
else:
self._thread_opp_transfer = ThreadOPPTransferFile(
self._queue, self._phone2, self._device, self._opp_local_file,
self._phone2.multimedia_path)
self._thread_opp_transfer_retry = ThreadOPPTransferFile(
self._queue, self._phone2, self._device, self._opp_local_file,
self._phone2.multimedia_path)
self._thread_opp_transfer.start()
time.sleep(LiveDualPhoneBTTransferSwitchBT.WAIT_BETWEEN_BT_SWITCH)
# Switch On/Off Bluetooth
self._bt_api.set_bt_power(str(BT_STATE.STATE_OFF))
time.sleep(LiveDualPhoneBTTransferSwitchBT.WAIT_BETWEEN_BT_SWITCH)
if self._bt_api.get_bt_power_status() != str(BT_STATE.STATE_OFF):
msg = "error switch off Bluetooth adapter"
self._logger.error(msg)
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
self._bt_api.set_bt_power(str(BT_STATE.STATE_ON))
time.sleep(LiveDualPhoneBTTransferSwitchBT.WAIT_BETWEEN_BT_SWITCH)
self._thread_opp_transfer.join()
try:
current_exception = self._queue.get(True, 3)
except Queue.Empty:
current_exception = None
if current_exception is None:
msg = "no error return after switch on/off BT during transfer"
self._logger.error(msg)
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
self._thread_opp_transfer_retry.start()
time.sleep(self._wait_btwn_cmd)
self._exception_reader(self._queue, [self._thread_opp_transfer_retry])
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Initialize the test
"""
LiveDualPhoneBTBase.set_up(self)
# Split to create a list of Initiator in case of multiple pairing
self._ini_list = self._initiator_list.strip().split(",")
# Split to create a list of phone_1 pairing request reply
self._reply_list1 = self._reply1_list.strip().split(",")
# Split to create a list of phone_2 pairing request reply
self._reply_list2 = self._reply2_list.strip().split(",")
# Check lists have the same number of iteration
if (not (range(len(self._ini_list)) == range(len(self._reply_list1)) ==
range(len(self._reply_list2)))):
msg = "INITIATOR_LIST, REPLY_LIST_1 and REPLY_LIST_2"\
+ " shall have same size"
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
# Change scan mode on both devices
if self._discov_mode1.upper() == "NOT_DISCOV":
self._bt_api.set_bt_discoverable("none", 0)
elif self._discov_mode1.upper() == "DISCOV_PAIR":
self._bt_api.set_bt_discoverable("connectable", 0)
elif self._discov_mode1.upper() == "DISCOV_ALL":
self._bt_api.set_bt_discoverable("both", 0)
else:
msg = "Wrong value of DISCOVERY_MODE_1"
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
if self._discov_mode2.upper() == "NOT_DISCOV":
self._bt_api2.set_bt_discoverable("none", 0)
elif self._discov_mode2.upper() == "DISCOV_PAIR":
self._bt_api2.set_bt_discoverable("connectable", 0)
elif self._discov_mode2.upper() == "DISCOV_ALL":
self._bt_api2.set_bt_discoverable("both", 0)
else:
msg = "Wrong value of DISCOVERY_MODE_2"
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
# Start a first BT scan on both devices to list visible remote
self._bt_api.bt_scan_devices()
self._bt_api2.bt_scan_devices()
return Global.SUCCESS, "No errors"
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LiveBTBase init function
LiveDualPhoneBTBase.__init__(self, tc_name, global_config)
self._dut_state = str(self._tc_parameters.get_param_value("DUT_STATE"))
self._opp_local_file = str(
self._tc_parameters.get_param_value("OPP_LOCAL_FILE"))
self._duration = str(self._tc_parameters.get_param_value("DURATION"))
self._thread_opp_transfer = None
self._thread_headset_activity = None
self._queue = Queue.Queue()
def set_up(self):
"""
Initialize the test
"""
LiveDualPhoneBTBase.set_up(self)
if self._dut_state not in ["DUT_CLIENT", "DUT_SERVER"]:
msg = "DUT state configuration unknown - DUT should be client or server"
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
opp_init_configure(self._device, self._phone2)
time.sleep(self._wait_btwn_cmd)
return Global.SUCCESS, "No errors"
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LiveBTBase init function
LiveDualPhoneBTBase.__init__(self, tc_name, global_config)
# Read DUT_STATE from test case xml file
self._dut_state = str(self._tc_parameters.get_param_value("DUT_STATE"))
# Read OPP_LOCAL_FILE from test case xml file
self._opp_local_file = str(
self._tc_parameters.get_param_value("OPP_LOCAL_FILE"))
# Initialize data
self._thread_opp_transfer = None
self._queue = Queue.Queue()
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LiveBTBase init function
LiveDualPhoneBTBase.__init__(self, tc_name, global_config)
LiveWifiBase.__init__(self, tc_name, global_config)
self._duration = str(self._tc_parameters.get_param_value("DURATION"))
self._dut_state = str(self._tc_parameters.get_param_value("DUT_STATE"))
self._opp_local_file = str(self._tc_parameters.get_param_value("OPP_LOCAL_FILE"))
self._wifi_activity = str(self._tc_parameters.get_param_value("WIFI_ACTIVITY"))
if self._wifi_activity == "WIFI_FTP_DOWNLOAD":
self._ftp_remote_file = str(self._tc_parameters.get_param_value("FTP_REMOTE_FILE"))
self._bt_headset = None
self._bt_headset_addr = None
def run_test(self):
"""
Execute the test
"""
# Call UseCase base run_test function
LiveDualPhoneBTBase.run_test(self)
queue = Queue.Queue()
# Configure BT OPP Transfer
opp_timeout = LabDualPhoneBTOppA2DPWithWiFiActivities.OFFSET_TIMEOUT + self._duration
if self._dut_state == "DUT_CLIENT":
thread_opp_transfer = ThreadOPPTransferFile(queue, self._device, self._phone2,
self._opp_local_file, self._device.multimedia_path, 1, 0, opp_timeout)
else:
thread_opp_transfer = ThreadOPPTransferFile(queue, self._phone2, self._device,
self._opp_local_file, self._phone2.multimedia_path, 1, 0, opp_timeout)
# Configure WiFi Activity
if self._wifi_activity == "WIFI_FTP_DOWNLOAD":
thread_wifi_activity = ThreadDownloadFileFromFTP(queue, self._networking_api,
self._server_ip_address, self._username,
self._password, self._ftp_remote_file, self._ftp_path,
str(self._device.get_ftpdir_path()),
LabDualPhoneBTOppA2DPWithWiFiActivities.OFFSET_TIMEOUT + self._duration)
else:
thread_wifi_activity = ThreadWiFiSwitchPowerScanAndConnect(queue, self._networking_api,
self._duration, self._ssid,
self._passphrase, self._security)
# Configure A2DP Activity
thread_a2dp_activity = ThreadA2DPCheckMusic(queue, BtAudioState.PLAYING, self._duration,
self._bt_api, self._bt_headset_addr)
# Launch threads
thread_opp_transfer.start()
time.sleep(LabDualPhoneBTOppA2DPWithWiFiActivities.WAIT_OPP_ACTIVITY_START)
thread_a2dp_activity.start()
thread_wifi_activity.start()
time.sleep(self._wait_btwn_cmd)
self._exception_reader(queue, [thread_a2dp_activity,
thread_opp_transfer, thread_wifi_activity])
return Global.SUCCESS, "No errors"
def tear_down(self):
"""
Finish the test and clear environment
"""
# Call UseCase base tear_down function
LiveDualPhoneBTBase.tear_down(self)
# Clear OPP transfer
opp_terminate(self._device, self._phone2)
# Delete sent file
if self._dut_state == "DUT_CLIENT":
self._bt_api2.bt_opp_init(self._opp_local_file)
else:
self._bt_api.bt_opp_init(self._opp_local_file)
return Global.SUCCESS, "No errors"
def run_test(self):
"""
Execute the test
"""
# Call UseCase base run_test function
LiveDualPhoneBTBase.run_test(self)
# Wifi configure if needed
if self._component_use in ["USE_WIFI", "USE_BT_AND_WIFI"]:
self._thread_scan_wifi = ThreadScanWiFi(self._queue,
self._networking_api,
self._ssid)
# Configure BT if needed
if self._component_use in ["USE_BT", "USE_BT_AND_WIFI"]:
self._thread_scan_bt = ThreadScanBT(self._queue, self._bt_api,
self._bt_api2)
# Configure BT OPP Transfer
if self._dut_state == "DUT_CLIENT":
self._thread_opp_transfer = ThreadOPPTransferFile(
self._queue, self._device, self._phone2, self._opp_local_file,
self._device.multimedia_path)
else:
self._thread_opp_transfer = ThreadOPPTransferFile(
self._queue, self._phone2, self._device, self._opp_local_file,
self._phone2.multimedia_path)
# Launch threads
self._thread_opp_transfer.start()
time.sleep(LiveDualPhoneBTTransferWithScan.SCANNING_WAIT_TIME)
if self._thread_scan_wifi is not None:
self._thread_scan_wifi.start()
if self._thread_scan_bt is not None:
self._thread_scan_bt.start()
self._exception_reader(self._queue, [
self._thread_scan_wifi, self._thread_scan_bt,
self._thread_opp_transfer
])
return Global.SUCCESS, "No errors"
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LiveBTBase init function
LiveDualPhoneBTBase.__init__(self, tc_name, global_config)
# Read INITIATOR_LIST from test case xml file
self._initiator_list = \
str(self._tc_parameters.get_param_value("INITIATOR_LIST"))
# Read REPLY_LIST_1 from test case xml file
self._reply1_list = \
str(self._tc_parameters.get_param_value("REPLY_LIST_1"))
# Read REPLY_LIST_2 from test case xml file
self._reply2_list = \
str(self._tc_parameters.get_param_value("REPLY_LIST_2"))
# Read DISCOVERY_MODE_1 from test case xml file
self._discov_mode1 = \
str(self._tc_parameters.get_param_value("DISCOVERY_MODE_1"))
# Read CODEPIN_1 from test case xml file
self._pin1 = \
str(self._tc_parameters.get_param_value("CODEPIN_1"))
# Read PASSKEY_1 from test case xml file
self._passkey1 = \
str(self._tc_parameters.get_param_value("PASSKEY_1"))
# Read DISCOVERY_MODE_2 from test case xml file
self._discov_mode2 = \
str(self._tc_parameters.get_param_value("DISCOVERY_MODE_2"))
# Read CODEPIN_2 from test case xml file
self._pin2 = \
str(self._tc_parameters.get_param_value("CODEPIN_2"))
# Read PASSKEY_2 from test case xml file
self._passkey2 = \
str(self._tc_parameters.get_param_value("PASSKEY_2"))
# Read DURATION from test case xml file
self._duration = \
int(self._tc_parameters.get_param_value("DURATION"))
self._ini_list = []
self._reply_list1 = []
self._reply_list2 = []
def tear_down(self):
"""
Execute the test
"""
# Call UseCase base tear_down function
LiveDualPhoneBTBase.tear_down(self)
# Clear OPP transfer
opp_terminate(self._device, self._phone2)
# Delete sent file
if self._dut_state == "DUT_CLIENT":
self._bt_api2.bt_opp_init(self._opp_local_file)
else:
self._bt_api.bt_opp_init(self._opp_local_file)
# Disable WiFi
self._networking_api.set_wifi_power(0)
return Global.SUCCESS, "No errors"
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LiveBTBase init function
LiveDualPhoneBTBase.__init__(self, tc_name, global_config)
# Get device_config
self._dut2_config = DeviceManager().get_device_config("PHONE2")
# Get TC Parameters
self._class_list = \
self._tc_parameters.get_param_value("CLASS_LIST")
self._initiator = \
self._tc_parameters.get_param_value("INITIATOR")
self._initiator_api = None
self._responder_addr = None
self._responder_config = None
def set_up(self):
"""
Initialize the test
"""
LiveDualPhoneBTBase.set_up(self)
self._bt_headset = self._em.get_bluetooth_headset("BT_HEADSET")
self._bt_headset_addr = self._bt_headset.get_bdaddress()
if self._wifi_activity == "WIFI_FTP_DOWNLOAD":
LiveWifiBase.set_up(self)
else:
self._networking_api.set_wifi_power(0)
if not str(self._duration).isdigit():
msg = "Bad value on duration parameter : %s" % self._duration
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
self._duration = int(self._duration)
if self._dut_state not in ["DUT_CLIENT", "DUT_SERVER"]:
msg = "DUT state configuration unknown - DUT should be client or server"
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
if self._wifi_activity not in ["WIFI_FTP_DOWNLOAD", "WIFI_SWITCH_SCAN_CONNECT"]:
msg = "Unknown WiFi activity : %s" % self._wifi_activity
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
# Configure OPP transfer
opp_init_configure(self._device, self._phone2)
# Connect to BT Headset
a2dp_pair_connect_to_headset(self._bt_api, self._bt_headset)
# Launch audio
a2dp_switch_music_state(self._bt_api, self._bt_headset, BtAudioCmd.PLAY)
return Global.SUCCESS, "No errors"
def tear_down(self):
"""
Execute the test
"""
# Call UseCase base tear_down function
LiveDualPhoneBTBase.tear_down(self)
# Clear OPP transfer
opp_terminate(self._device, self._phone2)
# WiFi configure if needed
if self._component_use == "USE_WIFI" or self._component_use == "USE_BT_AND_WIFI":
self._networking_api.set_wifi_power(0)
# Delete sent file
if self._dut_state == "DUT_CLIENT":
self._bt_api2.bt_opp_init(self._opp_local_file)
else:
self._bt_api.bt_opp_init(self._opp_local_file)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Initialize the test
"""
LiveDualPhoneBTBase.set_up(self)
# Configure iterations
if not str(self._duration).isdigit() or int(self._duration) < 1:
msg = "DURATION parameter error - must be >= 1 but is %s" % self._duration
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
self._duration = int(self._duration)
if self._dut_state not in ["DUT_CLIENT", "DUT_SERVER"]:
msg = "DUT state configuration unknown - DUT should be client or server"
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
# Configure OPP Transfer
opp_init_configure(self._device, self._phone2)
return Global.SUCCESS, "No errors"
def run_test(self):
"""
Execute the test
"""
# Call UseCase base run_test function
LiveDualPhoneBTBase.run_test(self)
# Configure BT OPP Transfer
if self._dut_state == "DUT_CLIENT":
self._thread_opp_transfer = ThreadOPPTransferFile(
self._queue, self._device, self._phone2, self._opp_local_file,
self._device.multimedia_path)
else:
self._thread_opp_transfer = ThreadOPPTransferFile(
self._queue, self._phone2, self._device, self._opp_local_file,
self._phone2.multimedia_path)
self._thread_opp_transfer.start()
time.sleep(LiveDualPhoneBTTransferSwitchWifi.WAIT_BETWEEN_WIFI_SWITCH)
# Switch On/Off WiFi
self._networking_api.set_wifi_power(0)
time.sleep(self._wait_btwn_cmd)
if self._networking_api.get_wifi_power_status() == 1:
msg = "DUT switch WiFi error"
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
self._networking_api.set_wifi_power(1)
time.sleep(self._wait_btwn_cmd)
if self._networking_api.get_wifi_power_status() == 0:
msg = "DUT switch WiFi error"
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
self._exception_reader(self._queue, [self._thread_opp_transfer])
return Global.SUCCESS, "No errors"
def run_test(self):
"""
Execute the test
"""
# pylint: disable=E1101
# Call UseCase base run_test function
LiveDualPhoneBTBase.run_test(self)
# Loop on list of initiator
for iteration in range(len(self._ini_list)):
# Remove leading and trailing whitespace
curr_ini = self._ini_list[iteration].strip().lower()
# Set Initiator and responder of the pairing request
if curr_ini in "phone1":
initiator_name = "phone1"
initiator_api = self._bt_api
initiator_addr = self._phone1_addr
initiator_rep = int(self._reply_list1[iteration].strip())
initiator_pin = self._pin1
initiator_pass = self._passkey1
responder_name = "phone2"
responder_api = self._bt_api2
responder_addr = self._phone2_addr
responder_rep = int(self._reply_list2[iteration].strip())
responder_pin = self._pin2
responder_pass = self._passkey2
elif curr_ini in "phone2":
initiator_name = "phone2"
initiator_api = self._bt_api2
initiator_addr = self._phone2_addr
initiator_rep = int(self._reply_list2[iteration].strip())
initiator_pin = self._pin2
initiator_pass = self._passkey2
responder_name = "phone1"
responder_api = self._bt_api
responder_addr = self._phone1_addr
responder_rep = int(self._reply_list1[iteration].strip())
responder_pin = self._pin1
responder_pass = self._passkey1
else:
msg = "Initiator value <%s> is not valid" % curr_ini
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
msg)
# Start pairing sequence
responder_api.wait_for_pairing(initiator_addr, 1, responder_rep,
responder_pin, responder_pass)
time.sleep(self._wait_btwn_cmd)
pair_result, pinvar = initiator_api.pair_to_device(
responder_addr, 1, initiator_rep, initiator_pin,
initiator_pass)
if pair_result == BT_BOND_STATE.BOND_NONE:
msg = "[PHONE1]%s is not paired with %s" \
% (initiator_name, responder_name)
self._logger.info(msg)
elif pair_result == BT_BOND_STATE.BOND_BONDED:
msg = "[PHONE1]%s is paired with %s" \
% (initiator_name, responder_name)
self._logger.info(msg)
else:
msg = "[PHONE1]Unexpected return value %s" % pair_result
self._logger.info(msg)
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
# In case of success pairing, wait for DURATION and
# check devices are still paired
if pair_result == BT_BOND_STATE.BOND_BONDED:
for i in range(self._duration):
if not i % 10:
msg = "[PHONE1]Wait for %d seconds" % (self._duration -
i)
self._logger.info(msg)
time.sleep(1)
# Retrieve list of paired devices
pairedflag = False
list_paired_devices = self._bt_api.list_paired_device()
for element in list_paired_devices:
if str(element.address).upper() \
== str(self._phone2_addr).upper():
self._logger.info(
"Still paired with device %s after %s s" %
(self._phone2_addr, self._duration))
pairedflag = True
break
if not pairedflag:
msg = "Pairing to device %s fail" % self._phone2_addr
self._logger.info(msg)
raise DeviceException(DeviceException.OPERATION_FAILED,
msg)
# analyze of pairing state for final verdict
if not self._is_verdict_pass(pair_result, pinvar, iteration):
msg = "[PHONE1]Unexpected pairing verdict %s" % pair_result
self._logger.info(msg)
self._display_param(pair_result, pinvar, iteration, "info")
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
else:
msg = "[PHONE1]pairing Verdict is PASS"
self._logger.info(msg)
self._display_param(pair_result, pinvar, iteration, "debug")
# If Responder is NOT discoverable
# Stop "WaitForPair" activity on Responder
self._stop_remaining_activity(iteration, responder_api)
# after end of loop, Remove pairing
time.sleep(self._wait_btwn_cmd)
list_paired_devices = self._bt_api.list_paired_device()
for element in list_paired_devices:
if str(element.address).upper() == str(self._phone2_addr).upper():
self._logger.info("Unpair both devices")
self._bt_api.unpair_bt_device(self._phone2_addr)
self._bt_api2.unpair_bt_device(self._phone1_addr)
return Global.SUCCESS, "No errors"
def run_test(self):
"""
As of right now, at the beginning of the RUN part, we have connected the 2 phones in
a PAN-NAP way and we are also connected to the internet.
"""
LiveDualPhoneBTBase.run_test(self)
# Configure Wifi Browse threads
if self._wifi_activity == "WIFI_WEB_BROWSING":
self._thread_wifi_activity = ThreadBrowseWifiChrome(
self._queue, self._panu_net_api, self._duration,
self._browse_retries, self._wifi_url)
else:
msg = "Unknown WIFI_ACTIVITY : %s" % self._wifi_activity
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
# search for the interface on the device, must be present
netcfg_cmd_up = "adb shell netcfg | grep bt-pan"
ifconfig_cmd_up = "adb shell ifconfig | grep -A8 bt-pan"
time.sleep(self._wait_btwn_cmd)
result_up, output_up = self._device.run_cmd(netcfg_cmd_up,
self._wait_btwn_cmd)
return_result = Global.SUCCESS
return_output = "The bt-pan interface is in the correct state"
if not output_up or "not found" in output_up:
result_up, output_up = self._device.run_cmd(
ifconfig_cmd_up, self._wait_btwn_cmd)
if not output_up:
# return_result = Global.SUCCESS
msg = "The bt-pan interface is not present, it was not instantiated"
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
elif "UP" not in output_up:
msg = "The bt-pan interface is present, but it is down. Output of grep command" \
" is: \n" + str(output_up)
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
elif "0.0.0.0/0" in output_up:
msg = "The bt-pan interface is present, but no IP was assigned. Output of grep command" \
" is: \n" + str(output_up)
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
else:
return_output = "The bt-pan interface is present and UP"
#browse for a page
self._thread_wifi_activity.start()
time.sleep(self._wait_btwn_cmd)
# This function waits all threads are dead or timeout is over before finish
self._exception_reader(self._queue, [self._thread_wifi_activity])
#turn off BT Tethering on the remote device
self._bluetooth_connectivity_obj.disconnect_bt_tethering_and_pan(
self._bt_tethering_deactivation_test, self._nap_api,
self._who_disconnect, self._panu_api, self._nap_addr,
self._panu_addr)
# search for the interface on the device, must not be present
netcfg_cmd_down = "adb shell netcfg | grep bt-pan"
time.sleep(self._wait_btwn_cmd)
self._device.run_cmd(netcfg_cmd_down, self._wait_btwn_cmd)
result_down, output_down = self._device.run_cmd(
netcfg_cmd_down, self._wait_btwn_cmd)
return_result = Global.SUCCESS
return_output = "The bt-pan interface is in the correct state"
if not output_down or "not found" in output_down:
result_down, output_down = self._device.run_cmd(
ifconfig_cmd_up, self._wait_btwn_cmd)
if output_down:
msg = "The bt-pan interface is still present, it was wrongly instantiated"
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
else:
return_output = "The bt-pan interface is no longer present, as expected."
return Global.SUCCESS, return_output
def run_test(self):
"""
As of right now, at the beginning of the RUN part, we have connected the 2 phones in
a PAN-NAP way and we are also connected to the internet.
"""
LiveDualPhoneBTBase.run_test(self)
# Configure Wifi Browse threads
if self._wifi_activity == "WIFI_WEB_BROWSING":
self._thread_wifi_activity = ThreadBrowseWifiChrome(self._queue, self._panu_net_api, self._duration, self._browse_retries, self._wifi_url)
else:
msg = "Unknown WIFI_ACTIVITY : %s" % self._wifi_activity
self._logger.error(msg)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, msg)
# search for the interface on the reference device, must be present
netcfg_cmd_up = "adb shell netcfg | grep bt-pan"
ifconfig_cmd_up = "adb shell ifconfig | grep -A8 bt-pan"
time.sleep(self._wait_btwn_cmd)
result_up, output_up = self._phone2.run_cmd(netcfg_cmd_up, self._wait_btwn_cmd)
return_result = Global.SUCCESS
return_output = "The bt-pan interface is in the correct state"
if not output_up or "not found" in output_up:
result_up, output_up = self._device.run_cmd(ifconfig_cmd_up, self._wait_btwn_cmd)
if not output_up:
msg = "The bt-pan interface is not present, it was not instantiated after first connection."
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
elif "UP" not in output_up:
msg = "The bt-pan interface is present, but it is down after first connection.. Output of grep command" \
" is: \n" + str(output_up)
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
elif "0.0.0.0/0" in output_up:
msg = "The bt-pan interface is present, but no IP was assigned after first connection.. Output of grep command" \
" is: \n" + str(output_up)
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
else:
return_output = "The bt-pan interface is present and UP"
#browse for a page
self._thread_wifi_activity.start()
time.sleep(self._wait_btwn_cmd)
# This function waits all threads are dead or timeout is over before finish
self._exception_reader(self._queue, [self._thread_wifi_activity])
#turn airplane mode ON
self._wifi_api.set_flight_mode(1)
time.sleep(BluetoothPanNapAirplane.WAIT_TIME_IN_FLIGHT_MODE)
#check BT, BT Tethering and Wifi are deactivated
#check BT status is OFF
time.sleep(self._wait_btwn_cmd)
bt_power_air_on = self._nap_api.get_bt_power_status()
if bt_power_air_on != str(BT_STATE.STATE_OFF):
msg = "After setting Airplane mode to ON, Bluetooth is still ON. Expected state is OFF." \
"the actual state is: " + bt_power_air_on
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
#check BT tethering is turned off
if self._nap_api.get_bt_tethering_power_status() != str(BT_STATE.STATE_OFF):
msg = "After setting Airplane mode to ON, Bluetooth TETHERING is still ON. Expected state is OFF."
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
#check Wifi status is OFF
if self._wifi_api.get_wifi_power_status == 1:
msg = "After setting Airplane mode to ON, WIFI is still ON. Expected state is OFF."
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
#turn ON BT and Wifi on DUT
self._nap_api.set_bt_power("on")
self._wifi_api.set_wifi_power("on")
self._nap_api.set_bt_tethering_power("on")
#check BT, BT Tethering and Wifi are reactivated. BT Tethering should be automatically re-activated
#check BT status is ON
time.sleep(self._wait_btwn_cmd)
bt_power_air_off = self._nap_api.get_bt_power_status()
if bt_power_air_off != str(BT_STATE.STATE_ON):
msg = "After setting Airplane mode to OFF, Bluetooth is still OFF. Expected state is ON." \
"the actual state is: " + bt_power_air_off
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
#check BT tethering is turned ON
if self._nap_api.get_bt_tethering_power_status() != str(BT_STATE.STATE_ON):
msg = "After setting Airplane mode to OFF, Bluetooth TETHERING is still OFF. Expected state is ON."
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
#check Wifi status is ON
if self._wifi_api.get_wifi_power_status == 1:
msg = "After setting Airplane mode to OFF, WIFI is still OFF. Expected state is ON."
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
#PAN-reconnect the devices
self._panu_api.connect_bt_device(self._nap_addr, BtProfile.PAN)
# search for the interface on the device, must not be present
netcfg_cmd_up = "adb shell netcfg | grep bt-pan"
ifconfig_cmd_up = "adb shell ifconfig | grep -A8 bt-pan"
time.sleep(self._wait_btwn_cmd)
result_up, output_up = self._phone2.run_cmd(netcfg_cmd_up, self._wait_btwn_cmd)
return_result = Global.SUCCESS
return_output = "The bt-pan interface is in the correct state"
if not output_up or "not found" in output_up:
result_up, output_up = self._device.run_cmd(ifconfig_cmd_up, self._wait_btwn_cmd)
if not output_up:
msg = "The bt-pan interface is not present, it was not instantiated after PAN-reconnecting. Message is: "+ str(output_up)
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
elif "UP" not in output_up:
msg = "The bt-pan interface is present, but it is down after PAN-reconnecting. Output of grep command" \
" is: \n" + str(output_up)
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
elif "0.0.0.0/0" in output_up:
msg = "The bt-pan interface is present, but no IP was assigned after PAN-reconnecting. Output of grep command" \
" is: \n" + str(output_up)
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
else:
return_output = "The bt-pan interface is present and UP"
#turn airplane mode OFF
self._wifi_api.set_flight_mode(0)
time.sleep(BluetoothPanNapAirplane.WAIT_TIME_IN_FLIGHT_MODE)
#check internet service was not stopped
# search for the interface on the reference device, must be present
netcfg_cmd_up = "adb shell netcfg | grep bt-pan"
time.sleep(self._wait_btwn_cmd)
result_up, output_up = self._phone2.run_cmd(netcfg_cmd_up, self._wait_btwn_cmd)
return_result = Global.SUCCESS
return_output = "The bt-pan interface is in the correct state"
if not output_up or "not found" in output_up:
result_up, output_up = self._device.run_cmd(ifconfig_cmd_up, self._wait_btwn_cmd)
if not output_up:
msg = "The bt-pan interface is not present, it was not instantiated after Airplane mode OFF"
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
elif "UP" not in output_up:
msg = "The bt-pan interface is present, but it is down after Airplane mode OFF. Output of grep command" \
" is: \n" + str(output_up)
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
elif "0.0.0.0/0" in output_up:
msg = "The bt-pan interface is present, but no IP was assigned after Airplane mode OFF. Output of grep command" \
" is: \n" + str(output_up)
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
else:
return_output = "The bt-pan interface is present and UP after Airplane mode OFF, the usecase fully passed."
return Global.SUCCESS, return_output