def test_send_message_failure_no_cellular(self):
if not toggle_airplane_mode_by_adb(self.log, self.MSE, True):
return False
bt_test_utils.reset_bluetooth([self.MSE])
bt_test_utils.connect_pri_to_sec(
self.MCE, self.MSE, set([BtEnum.BluetoothProfile.MAP_MCE.value]))
return not self.send_message([self.REMOTE])
def test_filters_suite_opportunistic_scan(self):
"""Test combinations of settings with opportunistic scanning.
Test combinations of valid advertisement data and scan settings. This
emphasises scan mode opportunistic.
Steps:
1. Generate testcases of the combination of valid_filter_suite and
settings dictionaries. This involves setting scan settings and
advertising settings.
Expected Result:
Scan filters match advertising settings and advertisements are found.
Returns:
Pass if True
Fail if False
TAGS: LE, Advertising, Filtering, Scanning, Opportunistic Scan
Priority: 1
"""
reset_bluetooth(self.android_devices)
valid_filter_suit = self._get_combinations(self.valid_filter_variants)
settings = [
{'mode':
AdvertiseSettingsAdvertiseMode.ADVERTISE_MODE_LOW_LATENCY.value,
'scan_mode': ScanSettingsScanMode.SCAN_MODE_LOW_LATENCY.value}
]
params = list(it.product(valid_filter_suit, settings))
failed = self.run_generated_testcases(self._magic,
params,
tag="filters_suite")
if failed:
return False
return True
def test_valid_filters(self):
"""Test combinations of settings with scanning and advertising.
Test combinations of valid advertisement data and scan settings.
Steps:
1. Generate testcases of the combination of valid_filters and
settings dictionaries. This involves setting scan settings and
advertising settings.
Expected Result:
Scan filters match advertising settings and advertisements are found.
Returns:
Pass if True
Fail if False
TAGS: LE, Advertising, Filtering, Scanning
Priority: 1
"""
reset_bluetooth(self.android_devices)
settings = [
{'mode':
AdvertiseSettingsAdvertiseMode.ADVERTISE_MODE_LOW_LATENCY.value}
]
params = list(it.product(self.valid_filter_suite, settings))
failed = self.run_generated_testcases(self._magic,
params,
tag="valid_filters")
if failed:
return False
return True
def setup_class(self):
self.hf = self.android_devices[0]
self.ag = self.android_devices[1]
self.re = self.android_devices[2]
self.ag_phone_number = "tel:{}".format(
self.ag.droid.telephonyGetLine1Number())
self.re_phone_number = "tel:{}".format(
self.re.droid.telephonyGetLine1Number())
self.log.info("ag tel: {} re tel: {}".format(self.ag_phone_number,
self.re_phone_number))
# Setup includes pairing and connecting the devices.
bt_test_utils.setup_multiple_devices_for_bt_test([self.hf, self.ag])
bt_test_utils.reset_bluetooth([self.hf, self.ag])
# Pair and connect the devices.
if not bt_test_utils.pair_pri_to_sec(self.hf.droid, self.ag.droid):
self.log.error("Failed to pair")
return False
# Connect the devices now, try twice.
attempts = 2
connected = False
while attempts > 0 and not connected:
connected = bt_test_utils.connect_pri_to_sec(
self.log, self.hf, self.ag.droid,
set([BtEnum.BluetoothProfile.HEADSET_CLIENT.value]))
self.log.info("Connected {}".format(connected))
attempts -= 1
return connected
def setup_class(self):
self.ad.droid.bluetoothFactoryReset()
# Factory reset requires a short delay to take effect
time.sleep(3)
self.ad.log.info("Making sure BT phone is enabled here during setup")
if not bluetooth_enabled_check(self.ad):
self.log.error("Failed to turn Bluetooth on DUT")
# Give a breathing time of short delay to take effect
time.sleep(3)
reset_bluetooth([self.ad])
# Determine if we have a relay-based device
if hasattr(self, 'relay_devices'):
for headphone in self.relay_devices:
headphone.setup()
'''
# Turn of the Power Supply for the headphones.
if hasattr(self, 'relay_devices'):
power_supply = self.relay_devices[0]
power_supply.power_off()
'''
super(HeadphoneTest, self).setup_class()
return clear_bonded_devices(self.ad)
def test_restart_scan_callback_after_bt_toggle(self):
"""Test to reuse an scan callback.
This will verify if scan objects can be reused after a bluetooth
toggle.
Steps:
1. Start a scanning instance.
3. Stop the scanning instance.
4. Toggle bluetooth off and on.
5. Start an scanning instance on the same objects used in step 1.
Expected Result:
Scanner should start successfully.
Returns:
Pass if True
Fail if False
TAGS: LE, Scanning, Stress
Priority: 1
"""
test_result = True
filter_list, scan_settings, scan_callback = generate_ble_scan_objects(
self.scn_ad.droid)
self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings,
scan_callback)
reset_bluetooth([self.scn_ad])
self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings,
scan_callback)
return test_result
def _start_advertisements_thread(self, ad, beacon_count, restart=False):
d, e = ad.droid, ad.ed
if restart:
try:
reset_bluetooth([ad])
except Exception:
self.log.debug("Failed resetting Bluetooth, continuing...")
return
try:
for _ in range(beacon_count):
d.bleSetAdvertiseDataIncludeDeviceName(True)
d.bleSetAdvertiseSettingsAdvertiseMode(
AdvertiseSettingsAdvertiseMode.ADVERTISE_MODE_LOW_LATENCY.
value)
advertise_callback, advertise_data, advertise_settings = (
generate_ble_advertise_objects(d))
d.bleStartBleAdvertising(advertise_callback, advertise_data,
advertise_settings)
try:
e.pop_event(adv_succ.format(advertise_callback),
self.default_timeout)
self.beacon_swarm_count += 1
local_bt_name = d.bluetoothGetLocalName()
if local_bt_name not in self.advertising_device_name_list:
self.advertising_device_name_list.append(
d.bluetoothGetLocalName())
except Exception as e:
self.log.info("Advertising failed due to " + str(e))
self.log.info("Beacons active: {}".format(
self.beacon_swarm_count))
except Exception:
self.log.debug(
"Something went wrong in starting advertisements, continuing.")
return
def setup_test(self):
# Reset bluetooth
reset_bluetooth(self.android_devices)
for ad in self.android_devices:
if not clear_bonded_devices(ad):
logging.error("Failed to unbound device")
return False
# Sync device time for timestamp comparison
sync_device_time(ad)
return super(BtMetricsTest, self).setup_test()
def test_toggle_bluetooth(self):
"""Stress test toggling bluetooth on and off.
Test the integrity of toggling bluetooth on and off.
Steps:
1. Toggle bluetooth off.
2. Toggle bluetooth on.
3. Repeat steps 1 and 2 one-hundred times.
Expected Result:
Each iteration of toggling bluetooth on and off should not cause an
exception.
Returns:
Pass if True
Fail if False
TAGS: Classic, Stress
Priority: 1
"""
for n in range(self.iterations):
self.log.info("Toggling bluetooth iteration {}.".format(n + 1))
if not reset_bluetooth([self.android_devices[0]]):
self.log.error("Failure to reset Bluetooth")
return False
return True
def setup_test(self):
# Reset the devices in a clean state.
bt_test_utils.setup_multiple_devices_for_bt_test(self.android_devices)
bt_test_utils.reset_bluetooth(self.android_devices)
for a in self.android_devices:
a.ed.clear_all_events()
# Pair the devices.
# This call may block until some specified timeout in bt_test_utils.py.
result = bt_test_utils.pair_pri_to_sec(self.car.droid, self.ph.droid)
asserts.assert_true(result, "pair_pri_to_sec returned false.");
# Check for successful setup of test.
devices = self.car.droid.bluetoothGetBondedDevices()
asserts.assert_equal(len(devices), 1, "pair_pri_to_sec succeeded but no bonded devices.")
def on_fail(self, test_name, begin_time):
take_btsnoop_logs(self.android_devices, self, test_name)
for _ in range(5):
if reset_bluetooth(self.android_devices):
break
else:
self.log.info("Failed to reset bluetooth state, retrying...")
def test_rfcomm_accept_timeout(self):
"""Test bluetooth RFCOMM accept socket timeout
Verify that RFCOMM connections are unsuccessful if
the socket timeout is exceeded.
Steps:
1. Get the mac address of the server device.
2. Establish an RFCOMM connection from the client to the server AD.
3. Verify that the RFCOMM connection is active from both the client and
server.
Expected Result:
RFCOMM connection is established then disconnected succcessfully.
Returns:
Pass if True
Fail if False
TAGS: Classic, RFCOMM
Priority: 1
"""
# Socket timeout set to 999ms
short_socket_timeout = 999
# Wait time in seconds before attempting a connection
wait_time_before_connect_attempt = 1
self.server_ad.droid.bluetoothStartPairingHelper()
self.client_ad.droid.bluetoothStartPairingHelper()
self.server_ad.droid.bluetoothRfcommBeginAcceptThread(
RfcommUuid.DEFAULT_UUID.value, short_socket_timeout)
time.sleep(wait_time_before_connect_attempt)
# Try to connect
self.client_ad.droid.bluetoothRfcommBeginConnectThread(
self.server_ad.droid.bluetoothGetLocalAddress())
# Give the connection time to fail
#time.sleep(self.default_timeout)
time.sleep(2)
if verify_server_and_client_connected(self.client_ad, self.server_ad):
return False
self.log.info("No active connections found as expected")
# AcceptThread has finished, kill hanging ConnectThread
self.client_ad.droid.bluetoothRfcommKillConnThread()
reset_bluetooth(self.android_devices)
return True
def test_restart_advertise_callback_after_bt_toggle(self):
"""Test starting an advertisement on a cleared out callback.
Test that a single device resets its callbacks when the bluetooth state
is reset.
Steps:
1. Setup the scanning android device.
2. Setup the advertiser android device.
3. Call start ble advertising.
4. Toggle bluetooth on and off.
5. Call start ble advertising on the same callback.
Expected Result:
Starting an advertisement on a callback id after toggling bluetooth
should fail.
Returns:
Pass if True
Fail if False
TAGS: LE, Advertising, Concurrency
Priority: 1
"""
test_result = True
advertise_callback, advertise_data, advertise_settings = (
generate_ble_advertise_objects(self.adv_ad.droid))
self.adv_ad.droid.bleStartBleAdvertising(advertise_callback,
advertise_data,
advertise_settings)
try:
self.adv_ad.ed.pop_event(adv_succ.format(advertise_callback),
self.default_timeout)
except Empty as error:
self.log.error("Test failed with Empty error: {}".format(error))
test_result = False
except concurrent.futures._base.TimeoutError as error:
self.log.debug(
"Test failed, filtering callback onSuccess never occurred: {}".
format(error))
test_result = reset_bluetooth([self.android_devices[1]])
if not test_result:
return test_result
self.adv_ad.droid.bleStartBleAdvertising(advertise_callback,
advertise_data,
advertise_settings)
try:
self.adv_ad.ed.pop_event(adv_succ.format(advertise_callback),
self.default_timeout)
except Empty as error:
self.log.error("Test failed with Empty error: {}".format(error))
test_result = False
except concurrent.futures._base.TimeoutError as error:
self.log.debug(
"Test failed, filtering callback onSuccess never occurred: {}".
format(error))
return test_result
def on_fail(self, test_name, begin_time):
self.log.debug("Test {} failed. Gathering bugreport and btsnoop logs".
format(test_name))
take_btsnoop_logs(self.android_devices, self, test_name)
self._take_bug_report(test_name, begin_time)
for _ in range(5):
if reset_bluetooth(self.android_devices):
break
else:
self.log.error("Failed to reset Bluetooth... retrying.")
return
def teardown_test(self):
try:
for thread in self.thread_list:
thread.join()
except Exception:
self.log.error("Failed to join threads.")
for _ in range(5):
if reset_bluetooth(self.android_devices):
break
else:
self.log.info("Failed to reset bluetooth state, retrying...")
time.sleep(20) #safeguard in case of connId errors
def test_bluetooth_reset(self):
"""Test resetting bluetooth.
Test the integrity of resetting bluetooth on Android.
Steps:
1. Toggle bluetooth off.
2. Toggle bluetooth on.
Returns:
Pass if True
Fail if False
"""
asserts.assert_true(bt_test_utils.reset_bluetooth([self.droid_ad]), "")
def test_max_advertisements_defaults(self):
"""Test scan integrity after BT state is reset
This test is to verify that LE devices are found
successfully after the Bluetooth stack is
reset. This is repeated multiple times in order
to verify that LE devices are not lost in scanning
when the stack is brought back up.
Steps:
1. Pre-Condition: Max advertisements are active
2. With the DUT android device, scan for all advertisements
and verify that all expected advertisements are found.
3. Reset Bluetooth on DUT.
4. Repeat steps 2-3 for defined iterations
Expected Result:
All expected advertisements should be found on all iterations.
Returns:
Pass if True
Fail if False
TAGS: LE, Advertising, Concurrency, Scanning
Priority: 2
"""
filter_list = self.scn_ad.droid.bleGenFilterList()
self.scn_ad.droid.bleBuildScanFilter(filter_list)
self.scn_ad.droid.bleSetScanSettingsCallbackType(
ble_scan_settings_callback_types['all_matches'])
self.scn_ad.droid.bleSetScanSettingsScanMode(
ble_scan_settings_modes['low_latency'])
iterations = 20
for _ in range(iterations):
self.log.info("Verify all advertisements found")
try:
if not scan_and_verify_n_advertisements(
self.scn_ad, self.max_advertisements):
self.log.error("Failed to find all advertisements")
return False
except BtTestUtilsError:
return False
if not reset_bluetooth([self.scn_ad]):
self.log.error("Failed to reset Bluetooth state")
return False
return True
def test_bluetooth_reset(self):
"""Test resetting bluetooth.
Test the integrity of resetting bluetooth on Android.
Steps:
1. Toggle bluetooth off.
2. Toggle bluetooth on.
Expected Result:
Bluetooth should toggle on and off without failing.
Returns:
Pass if True
Fail if False
TAGS: Classic
Priority: 1
"""
return reset_bluetooth([self.droid_ad])
def on_fail(self, test_name, begin_time):
take_btsnoop_logs(self.android_devices, self, test_name)
reset_bluetooth([self.scn_ad])
def setup_test(self):
super(BluetoothBaseTest, self).setup_test()
return reset_bluetooth(self.android_devices)
def teardown_test(self):
self.log.debug(log_energy_info(self.android_devices, "End"))
reset_bluetooth([self.android_devices[0]])
return True
def cleanup_class(self):
return reset_bluetooth(self.android_devices)
def teardown_test(self):
reset_bluetooth([self.android_devices[0]])
return True
def test_toggle_advertiser_bt_state(self):
"""Test forcing stopping advertisements.
Test that a single device resets its callbacks when the bluetooth state is
reset. There should be no advertisements.
Steps:
1. Setup the scanning android device.
2. Setup the advertiser android device.
3. Call start ble advertising.
4. Toggle bluetooth on and off.
5. Scan for any advertisements.
Expected Result:
No advertisements should be found after toggling Bluetooth on the
advertising device.
Returns:
Pass if True
Fail if False
TAGS: LE, Advertising, Concurrency
Priority: 2
"""
test_result = True
self.adv_ad.droid.bleSetAdvertiseDataIncludeDeviceName(True)
advertise_callback, advertise_data, advertise_settings = (
generate_ble_advertise_objects(self.adv_ad.droid))
self.adv_ad.droid.bleStartBleAdvertising(advertise_callback,
advertise_data,
advertise_settings)
try:
self.adv_ad.ed.pop_event(adv_succ.format(advertise_callback),
self.default_timeout)
except Empty as error:
self.log.error("Test failed with Empty error: {}".format(error))
return False
except concurrent.futures._base.TimeoutError as error:
self.log.error(
"Test failed, filtering callback onSuccess never occurred: {}".
format(error))
self.scn_ad.droid.bleSetScanFilterDeviceName(
self.adv_ad.droid.bluetoothGetLocalName())
filter_list, scan_settings, scan_callback = generate_ble_scan_objects(
self.scn_ad.droid)
self.scn_ad.droid.bleBuildScanFilter(filter_list)
self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings,
scan_callback)
try:
self.scn_ad.ed.pop_event(scan_result.format(scan_callback),
self.default_timeout)
except Empty as error:
self.log.error("Test failed with: {}".format(error))
return False
self.scn_ad.droid.bleStopBleScan(scan_callback)
test_result = reset_bluetooth([self.android_devices[1]])
self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings,
scan_callback)
if not test_result:
return False
try:
expected_event = scan_result.format(scan_callback)
event = self.scn_ad.ed.pop_event(expected_event,
self.default_timeout)
self.log.error("Event {} not expected. Found: {}".format(
expected_event, event))
return False
except Empty as error:
self.log.debug("Test passed with: {}".format(error))
self.scn_ad.droid.bleStopBleScan(scan_callback)
self.adv_ad.droid.bleStopBleAdvertising(advertise_callback)
return True
def setup_test(self):
return reset_bluetooth(self.android_devices)
def on_fail(self, test_name, begin_time):
self.log.debug(
"Test {} failed. Gathering bugreport and btsnoop logs.".format(
test_name))
take_btsnoop_logs(self.android_devices, self, test_name)
reset_bluetooth(self.android_devices)
def on_exception(self, test_name, begin_time):
reset_bluetooth(self.android_devices)
def test_bt_toggle(self):
"""
Test that simply toggle bluetooth
:return:
"""
return reset_bluetooth([self.android_devices[0]])
def test_restart_advertise_callback_after_bt_toggle(self):
"""Test to reuse an advertise callback.
This will verify if advertising objects can be reused after a bluetooth
toggle.
Steps:
1. Start a advertising instance.
2. Find that an onSuccess callback is triggered.
3. Stop the advertising instance.
4. Toggle bluetooth off and on.
5. Start an advertising instance on the same objects used in step 1.
6. Find that an onSuccess callback is triggered.
Expected Result:
Advertisement should start successfully.
Returns:
Pass if True
Fail if False
TAGS: LE, Advertising, Stress
Priority: 1
"""
test_result = True
advertise_callback, advertise_data, advertise_settings = generate_ble_advertise_objects(
self.adv_ad.droid)
self.adv_ad.droid.bleStartBleAdvertising(advertise_callback,
advertise_data,
advertise_settings)
expected_advertise_event_name = "".join(
["BleAdvertise",
str(advertise_callback), "onSuccess"])
worker = self.adv_ad.ed.handle_event(
self.bleadvertise_verify_onsuccess_handler,
expected_advertise_event_name, ([]), self.default_timeout)
try:
self.log.debug(worker.result(self.default_timeout))
except Empty as error:
self.log.debug(" ".join(
["Test failed with Empty error:",
str(error)]))
test_result = False
except concurrent.futures._base.TimeoutError as error:
self.log.debug(" ".join([
"Test failed, filtering callback onSuccess never occurred:",
str(error)
]))
test_result = reset_bluetooth([self.scn_ad])
if not test_result:
return test_result
time.sleep(5)
self.adv_ad.droid.bleStartBleAdvertising(advertise_callback,
advertise_data,
advertise_settings)
worker = self.adv_ad.ed.handle_event(
self.bleadvertise_verify_onsuccess_handler,
expected_advertise_event_name, ([]), self.default_timeout)
try:
self.log.debug(worker.result(self.default_timeout))
except Empty as error:
self.log.debug(" ".join(
["Test failed with Empty error:",
str(error)]))
test_result = False
except concurrent.futures._base.TimeoutError as error:
self.log.debug(" ".join([
"Test failed, filtering callback onSuccess never occurred:",
str(error)
]))
return test_result
