def test_scan_advertisement_with_device_service_uuid_filter_expect_no_events(
self):
"""Test scan filtering against an advertisement with no data.
Test that exercises a service uuid filter on the scanner but no server
uuid added to the advertisement.
Steps:
1. Setup the scanning android device with scan filter including a
service uuid and mask.
2. Setup the advertiser android devices.
3. Verify that no onScanResults were triggered.
Expected Result:
Verify no advertisements found.
Returns:
Pass if True
Fail if False
TAGS: LE, Advertising, Filtering, Scanning
Priority: 1
"""
test_result = True
service_uuid = "00000000-0000-1000-8000-00805F9B34FB"
service_mask = "00000000-0000-1000-8000-00805F9B34FA"
self.scn_ad.droid.bleSetScanFilterServiceUuid(service_uuid,
service_mask)
self.adv_ad.droid.bleSetAdvertiseSettingsAdvertiseMode(
ble_advertise_settings_modes['low_latency'])
filter_list, scan_settings, scan_callback = generate_ble_scan_objects(
self.scn_ad.droid)
expected_event_name = scan_result.format(scan_callback)
self.adv_ad.droid.bleSetAdvertiseDataIncludeDeviceName(True)
self.adv_ad.droid.bleSetAdvertiseDataIncludeTxPowerLevel(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)
self.scn_ad.droid.bleSetScanFilterDeviceName(
self.adv_ad.droid.bluetoothGetLocalName())
self.scn_ad.droid.bleBuildScanFilter(filter_list)
self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings,
scan_callback)
worker = self.scn_ad.ed.handle_event(
self.blescan_verify_onscanresult_event_handler,
expected_event_name, ([1]), self.default_timeout)
try:
event_info = self.scn_ad.ed.pop_event(expected_event_name,
self.default_timeout)
self.log.error(
"Unexpectedly found an advertiser: {}".format(event_info))
test_result = False
except Empty as error:
self.log.debug("No events were found as expected.")
self.scn_ad.droid.bleStopBleScan(scan_callback)
self.adv_ad.droid.bleStopBleAdvertising(advertise_callback)
return test_result
def test_legacy_scan_result_raw_length(self):
"""Test that raw scan record data in legacy scan is 62 bytes long.
This is required for compability with older apps that make this
assumption.
Steps:
1. Start legacy advertising set on dut1
2. Start scanning on dut0, scan filter set to advertiser's device name
3. Try to find an event, expect found, verify scan recurd data length
4. Stop advertising
Expected Result:
Scan finds a legacy advertisement of proper size
Returns:
Pass if True
Fail if False
TAGS: LE Advertising Extension, BT5, LE, Advertising, Scanning
Priority: 1
"""
adv_callback = self.adv_ad.droid.bleAdvSetGenCallback()
self.adv_ad.droid.bleAdvSetStartAdvertisingSet(
{
"connectable": True,
"scannable": True,
"legacyMode": True,
"interval": 320
}, {"includeDeviceName": True}, None, None, None, 0, 0,
adv_callback)
self.scn_ad.droid.bleSetScanSettingsLegacy(True)
self.scn_ad.droid.bleSetScanSettingsPhy(ble_scan_settings_phys['1m'])
filter_list, scan_settings, scan_callback = generate_ble_scan_objects(
self.scn_ad.droid)
adv_device_name = self.adv_ad.droid.bluetoothGetLocalName()
self.scn_ad.droid.bleSetScanFilterDeviceName(adv_device_name)
self.scn_ad.droid.bleBuildScanFilter(filter_list)
self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings,
scan_callback)
self.active_scan_callback_list.append(scan_callback)
try:
evt = self.scn_ad.ed.pop_event(scan_result.format(scan_callback),
self.default_timeout)
rawData = evt['data']['Result']['scanRecord']
asserts.assert_true(62 == len(rawData.split(",")),
"Raw data should be 62 bytes long.")
except Empty:
self.log.error("Scan result not found")
self.adv_ad.droid.bleAdvSetStopAdvertisingSet(adv_callback)
return False
self.adv_ad.droid.bleAdvSetStopAdvertisingSet(adv_callback)
return True
def test_scan_trigger_on_batch_scan_results(self):
"""Test triggering batch scan results.
Test that triggers onBatchScanResults and verifies the time to trigger
within one second leeway.
Steps:
1. Setup the scanning android device with report delay seconds set to
5000.
2. Setup the advertiser android devices.
3. Verify that only one onBatchScanResult callback was triggered.
4. Compare the system time that the scan was started with the elapsed
time that is in the callback.
Expected Result:
The scan event dispatcher should find an onBatchScanResult event.
Returns:
Pass if True
Fail if False
TAGS: LE, Advertising, Filtering, Scanning, Batch Scanning
Priority: 2
"""
test_result = True
self.scn_ad.droid.bleSetScanSettingsReportDelayMillis(5000)
filter_list, scan_settings, scan_callback = generate_ble_scan_objects(
self.scn_ad.droid)
expected_event_name = batch_scan_result.format(scan_callback)
self.adv_ad.droid.bleSetAdvertiseDataIncludeDeviceName(True)
self.adv_ad.droid.bleSetAdvertiseDataIncludeTxPowerLevel(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)
self.scn_ad.droid.bleSetScanFilterDeviceName(
self.adv_ad.droid.bluetoothGetLocalName())
self.scn_ad.droid.bleBuildScanFilter(filter_list)
self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings,
scan_callback)
system_time_nanos = self.scn_ad.droid.getSystemElapsedRealtimeNanos()
self.log.debug("Current system time: {}".format(system_time_nanos))
worker = self.scn_ad.ed.handle_event(
self.blescan_verify_onbatchscanresult_event_handler,
expected_event_name, ([system_time_nanos, 5000000000]),
self.default_timeout)
try:
self.log.debug(worker.result(self.default_timeout))
except Empty as error:
test_result = False
self.log.debug("Test failed with: {}".format(error))
except concurrent.futures._base.TimeoutError as error:
test_result = False
self.log.debug("Test failed with: {}".format(error))
self.scn_ad.droid.bleStopBleScan(scan_callback)
self.adv_ad.droid.bleStopBleAdvertising(advertise_callback)
return test_result
def test_1m_2m_extended_scan(self):
"""Test scan on LE 1M PHY using LE 2M PHY as secondary.
Tests test verify that device is able to receive extended advertising
on 1M PHY when secondary is 2M PHY.
Steps:
1. Start advertising set on dut1
2. Start scanning on dut0, scan filter set to advertiser's device name
3. Try to find an event, expect found
4. Stop advertising
Expected Result:
Scan finds a advertisement.
Returns:
Pass if True
Fail if False
TAGS: LE Advertising Extension, BT5, LE, Advertising, Scanning
Priority: 1
"""
adv_callback = self.adv_ad.droid.bleAdvSetGenCallback()
self.adv_ad.droid.bleAdvSetStartAdvertisingSet(
{
"connectable": True,
"legacyMode": False,
"primaryPhy": "PHY_LE_1M",
"secondaryPhy": "PHY_LE_2M",
"interval": 320
}, self.big_adv_data, None, None, None, 0, 0, adv_callback)
self.scn_ad.droid.bleSetScanSettingsLegacy(False)
self.scn_ad.droid.bleSetScanSettingsPhy(ble_scan_settings_phys['1m'])
filter_list, scan_settings, scan_callback = generate_ble_scan_objects(
self.scn_ad.droid)
adv_device_name = self.adv_ad.droid.bluetoothGetLocalName()
self.scn_ad.droid.bleSetScanFilterDeviceName(adv_device_name)
self.scn_ad.droid.bleBuildScanFilter(filter_list)
self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings,
scan_callback)
self.active_scan_callback_list.append(scan_callback)
try:
self.scn_ad.ed.pop_event(scan_result.format(scan_callback),
self.default_timeout)
except Empty:
self.log.error("Scan result not found")
self.adv_ad.droid.bleAdvSetStopAdvertisingSet(adv_callback)
return False
self.adv_ad.droid.bleAdvSetStopAdvertisingSet(adv_callback)
return True
def test_scan_flush_pending_scan_results(self):
"""Test LE scan api flush pending results.
Test that flush pending scan results doesn't affect onScanResults from
triggering.
Steps:
1. Setup the scanning android device.
2. Setup the advertiser android devices.
3. Trigger bluetoothFlushPendingScanResults on the scanning droid.
4. Verify that only one onScanResults callback was triggered.
Expected Result:
After flushing pending scan results, make sure only one onScanResult
callback was triggered.
Returns:
Pass if True
Fail if False
TAGS: LE, Advertising, Filtering, Scanning
Priority: 1
"""
test_result = True
self.adv_ad.droid.bleSetAdvertiseDataIncludeDeviceName(True)
self.adv_ad.droid.bleSetAdvertiseSettingsAdvertiseMode(
ble_advertise_settings_modes['low_latency'])
filter_list, scan_settings, scan_callback = generate_ble_scan_objects(
self.scn_ad.droid)
expected_event_name = scan_result.format(scan_callback)
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)
self.scn_ad.droid.bleSetScanFilterDeviceName(
self.adv_ad.droid.bluetoothGetLocalName())
self.scn_ad.droid.bleBuildScanFilter(filter_list)
self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings,
scan_callback)
self.scn_ad.droid.bleFlushPendingScanResults(scan_callback)
worker = self.scn_ad.ed.handle_event(
self.blescan_verify_onscanresult_event_handler,
expected_event_name, ([1]), self.default_timeout)
try:
self.log.debug(worker.result(self.default_timeout))
except Empty as error:
test_result = False
self.log.error("Test failed with Empty error: {}".format(error))
except concurrent.futures._base.TimeoutError as error:
test_result = False
self.log.error("Test failed with TimeoutError: {}".format(error))
self.scn_ad.droid.bleStopBleScan(scan_callback)
self.adv_ad.droid.bleStopBleAdvertising(advertise_callback)
return test_result
def test_swarm_rotate_addresses(self):
"""Test basic LE scan filtering in a mass beacon deployment.
Test finding LE scan results in a mass beacon deployment. This test
rotates the mac address of the advertising devices at a consistent
interval in order to make the scanning device think there are
thousands of devices nearby.
Steps:
1. Assume that mass beacon deployment is setup with device names
advertising.
2. Set LE scanning mode to low latency on 28 scan instances.
3. Start LE scan on each of the scan instances.
5. Continuously Pop scan results matching the scan filter.
6. Rotate mac address of each advertising device sequentially.
7. 5-6 10,000 times.
8. Stop LE scanning
Expected Result:
The Bluetooth stack doesn't crash.
Returns:
Pass if True
Fail if False
TAGS: LE, Scanning, Beacon
Priority: 1
"""
scan_callback_list = []
for _ in range(28):
self.scn_ad.droid.bleSetScanSettingsScanMode(
ScanSettingsScanMode.SCAN_MODE_LOW_LATENCY.value)
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)
scan_callback_list.append(scan_callback)
thread = threading.Thread(
target=self._restart_special_advertisements_thread, args=())
thread.start()
n = 0
while n < 10000:
for cb in scan_callback_list:
event_info = self.scn_ad.ed.pop_event(scan_result.format(cb),
self.default_timeout)
mac_address = event_info['data']['Result']['deviceInfo'][
'address']
if mac_address not in self.discovered_mac_address_list:
self.discovered_mac_address_list.append(mac_address)
self.log.info("Discovered {} different devices.".format(
len(self.discovered_mac_address_list)))
n += 1
self.scn_ad.droid.bleStopBleScan(scan_callback)
return True
def test_gatt_connect_stress(self):
"""Test the round trip speed of connecting to a peripheral many times
This test will prompt the user to press "Enter" when the
peripheral is in a connecable advertisement state. Once
the user presses enter, this script will measure the amount
of time it takes to establish a GATT connection to the
peripheral. The test will then disconnect. It will attempt to
repeat this process multiple times.
Steps:
1. Wait for user input to confirm peripheral is advertising.
2. Start timer
3. Perform GATT connection to peripheral
4. Upon successful connection, stop timer
5. Disconnect from peripheral
6. Repeat steps 2-5 1000 times.
Expected Result:
Test should measure 1000 iterations of connect/disconnect cycles.
Returns:
Pass if True
Fail if False
TAGS: LE, GATT
Priority: 2
"""
filter_list, scan_settings, scan_callback = generate_ble_scan_objects(
self.cen_ad.droid)
self.cen_ad.droid.bleStartBleScan(filter_list, scan_settings,
scan_callback)
self.AUTOCONNECT = False
iterations = 1000
n = 0
while n < iterations:
self.start_timer()
try:
bluetooth_gatt, gatt_callback = (setup_gatt_connection(
self.cen_ad, self.ble_mac_address, self.AUTOCONNECT,
gatt_transport['le']))
except GattTestUtilsError as err:
self.log.error(err)
return False
self.log.info("Total time (ms): {}".format(self.end_timer()))
try:
disconnect_gatt_connection(self.cen_ad, bluetooth_gatt,
gatt_callback)
self.cen_ad.droid.gattClientClose(bluetooth_gatt)
except GattTestUtilsError as err:
self.log.error(err)
return False
n += 1
return True
def test_duration(self):
"""Test scanning duration
Tests BT5.0 scanning duration
Steps:
1. Start advertising set
2. Start 5.0 scan
3. Scan for advertisement event
Expected Result:
Scan finds a legacy advertisement of proper size
Returns:
Pass if True
Fail if False
TAGS: BT5.0, LE, Advertising, Scanning
Priority: 1
"""
adv_callback = self.adv_ad.droid.bleAdvSetGenCallback()
self.adv_ad.droid.bleAdvSetStartAdvertisingSet(
{
"connectable": True,
"legacyMode": False,
"primaryPhy": "PHY_LE_1M",
"secondaryPhy": "PHY_LE_2M",
"interval": 320
}, self.big_adv_data, None, None, None, 0, 0, adv_callback)
self.scn_ad.droid.bleSetScanSettingsLegacy(False)
self.scn_ad.droid.bleSetScanSettingsPhy(ble_scan_settings_phys['1m'])
filter_list, scan_settings, scan_callback = generate_ble_scan_objects(
self.scn_ad.droid)
adv_device_name = self.adv_ad.droid.bluetoothGetLocalName()
self.scn_ad.droid.bleSetScanFilterDeviceName(adv_device_name)
self.scn_ad.droid.bleBuildScanFilter(filter_list)
self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings,
scan_callback)
self.active_scan_callback_list.append(scan_callback)
try:
self.scn_ad.ed.pop_event(scan_result.format(scan_callback),
self.default_timeout)
except Empty:
self.log.error("Scan result not found")
self.adv_ad.droid.bleAdvSetStopAdvertisingSet(adv_callback)
return False
self.adv_ad.droid.bleAdvSetStopAdvertisingSet(adv_callback)
return True
def test_scan_flush_results_without_on_batch_scan_results_triggered(self):
"""Test that doesn't expect a batch scan result.
Test flush pending scan results with a report delay seconds set to 0.
No onBatchScanResults callback should be triggered.
Steps:
1. Setup the scanning android device with report delay seconds set to 0
(or just use default).
2. Setup the advertiser android devices.
Expected Result:
Verify that no onBatchScanResults were triggered.
Returns:
Pass if True
Fail if False
TAGS: LE, Advertising, Filtering, Scanning, Batch Scanning
Priority: 2
"""
test_result = True
filter_list, scan_settings, scan_callback = generate_ble_scan_objects(
self.scn_ad.droid)
expected_event_name = batch_scan_result.format(scan_callback)
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)
self.scn_ad.droid.bleSetScanFilterDeviceName(
self.adv_ad.droid.bluetoothGetLocalName())
self.scn_ad.droid.bleBuildScanFilter(filter_list)
self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings,
scan_callback)
worker = self.scn_ad.ed.handle_event(
self.blescan_verify_onbatchscanresult_event_handler,
expected_event_name, ([]), self.default_timeout)
self.scn_ad.droid.bleFlushPendingScanResults(scan_callback)
try:
event_info = self.scn_ad.ed.pop_event(expected_event_name, 10)
self.log.debug(
"Unexpectedly found an advertiser: {}".format(event_info))
test_result = False
except Empty:
self.log.debug("No {} events were found as expected.".format(
batch_scan_result))
self.scn_ad.droid.bleStopBleScan(scan_callback)
self.adv_ad.droid.bleStopBleAdvertising(advertise_callback)
return test_result
def test_scan_non_existent_name_filter(self):
"""Test non-existent name filter.
Test scan filter on non-existent device name.
Steps:
1. Setup the scanning android device with scan filter for device name
set to an unexpected value.
2. Setup the advertiser android devices.
3. Verify that no onScanResults were triggered.
Expected Result:
No advertisements were found.
Returns:
Pass if True
Fail if False
TAGS: LE, Advertising, Filtering, Scanning
Priority: 2
"""
test_result = True
filter_name = "{}_probably_wont_find".format(
self.adv_ad.droid.bluetoothGetLocalName())
self.adv_ad.droid.bleSetAdvertiseDataIncludeDeviceName(True)
self.scn_ad.droid.bleSetScanFilterDeviceName(filter_name)
filter_list, scan_settings, scan_callback = generate_ble_scan_objects(
self.scn_ad.droid)
self.scn_ad.droid.bleBuildScanFilter(filter_list)
expected_event_name = scan_result.format(scan_callback)
self.adv_ad.droid.bleSetAdvertiseDataIncludeDeviceName(True)
self.adv_ad.droid.bleSetAdvertiseDataIncludeTxPowerLevel(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)
self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings,
scan_callback)
try:
event_info = self.scn_ad.ed.pop_event(expected_event_name,
self.default_timeout)
self.log.error(
"Unexpectedly found an advertiser: {}".format(event_info))
test_result = False
except Empty:
self.log.debug("No events were found as expected.")
self.scn_ad.droid.bleStopBleScan(scan_callback)
self.adv_ad.droid.bleStopBleAdvertising(advertise_callback)
return test_result
def test_swarm_scan_result_filter_each_device_name(self):
"""Test basic LE scan filtering in a mass beacon deployment.
Test finding LE scan results in a mass beacon deployment. This
test specifically tests scan filtering of different device names and
that each device name is found.
Steps:
1. Assume that mass beacon deployment is setup with device names
advertising.
2. Set LE scanning mode to low latency.
3. Filter device name from one of the known advertising device names
4. Start LE scan.
5. Pop scan results matching the scan filter.
6. Stop LE scanning.
7. Repeat steps 2-6 until all advertising device names are found.
Expected Result:
All advertising beacons are found by their device name.
Returns:
Pass if True
Fail if False
TAGS: LE, Scanning, Beacon, Filtering
Priority: 1
"""
for filter_name in self.advertising_device_name_list:
self.scn_ad.droid.bleSetScanSettingsScanMode(
ScanSettingsScanMode.SCAN_MODE_LOW_LATENCY.value)
filter_list, scan_settings, scan_callback = (
generate_ble_scan_objects(self.scn_ad.droid))
try:
self.scn_ad.droid.bleSetScanFilterDeviceName(filter_name)
self.scn_ad.droid.bleBuildScanFilter(filter_list)
self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings,
scan_callback)
self.log.debug(
self.scn_ad.ed.pop_event(scan_result.format(scan_callback),
self.default_timeout))
except Exception:
self.log.info(
"Couldn't find advertiser name {}.".format(filter_name))
return False
self.scn_ad.droid.bleStopBleScan(scan_callback)
return True
def test_swarm_10000_on_batch_scan_result(self):
"""Test LE batch scanning in a mass beacon deployment.
Test finding 10000 LE batch scan results in a mass beacon deployment.
Steps:
1. Assume that mass beacon deployment is setup.
2. Set LE scanning mode to low latency and report delay millis to 1
second.
3. Start LE scan.
4. Pop batch scan results off the event dispatcher 10000 times.
5. Stop LE scanning.
Expected Result:
1000 scan results should be found without any exceptions.
Returns:
Pass if True
Fail if False
TAGS: LE, Scanning, Beacon
Priority: 1
"""
self.scn_ad.droid.bleSetScanSettingsScanMode(
ScanSettingsScanMode.SCAN_MODE_LOW_LATENCY.value)
self.scn_ad.droid.bleSetScanSettingsReportDelayMillis(1000)
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)
for _ in range(10000):
event_info = self.scn_ad.ed.pop_event(
batch_scan_result.format(scan_callback), self.default_timeout)
for result in event_info['data']['Results']:
mac_address = result['deviceInfo']['address']
if mac_address not in self.discovered_mac_address_list:
self.discovered_mac_address_list.append(mac_address)
self.log.info("Discovered {} different devices.".format(
len(self.discovered_mac_address_list)))
self.scn_ad.droid.bleStopBleScan(scan_callback)
return True
def _is_peripheral_advertising(self):
self.cen_ad.droid.bleSetScanFilterDeviceAddress(self.ble_mac_address)
self.cen_ad.droid.bleSetScanSettingsScanMode(
ble_scan_settings_modes['low_latency'])
filter_list, scan_settings, scan_callback = generate_ble_scan_objects(
self.cen_ad.droid)
self.cen_ad.droid.bleBuildScanFilter(filter_list)
self.cen_ad.droid.bleStartBleScan(filter_list, scan_settings,
scan_callback)
expected_event_name = scan_result.format(scan_callback)
test_result = True
try:
self.cen_ad.ed.pop_event(expected_event_name, self.DEFAULT_TIMEOUT)
self.log.info(
"Peripheral found with event: {}".format(expected_event_name))
except Empty:
self.log.info("Peripheral not advertising or not found: {}".format(
self.ble_mac_address))
test_result = False
self.cen_ad.droid.bleStopBleScan(scan_callback)
return test_result
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.bleSetScanSettingsScanMode(
ble_scan_settings_modes['low_latency'])
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 test_scan_filter_device_address(self):
"""Test scan filtering of a device address.
This test will have to create two scanning instances. The first will
have no filters and will find the generic advertisement's mac address.
The second will have a filter of the found mac address.
Steps:
1. Start a generic advertisement.
2. Start a generic scanner.
3. Find the advertisement and extract the mac address.
4. Stop the first scanner.
5. Create a new scanner with scan filter with a mac address filter of
what was found in step 3.
6. Start the scanner.
Expected Result:
Verify that the advertisement was found in the second scan instance.
Returns:
Pass if True
Fail if False
TAGS: LE, Advertising, Filtering, Scanning
Priority: 1
"""
test_result = True
self.scn_ad.droid.bleSetScanSettingsScanMode(
ble_scan_settings_modes['low_latency'])
filter_list, scan_settings, scan_callback = generate_ble_scan_objects(
self.scn_ad.droid)
expected_event_name = scan_result.format(scan_callback)
self.adv_ad.droid.bleSetAdvertiseSettingsAdvertiseMode(
ble_advertise_settings_modes['low_latency'])
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)
self.scn_ad.droid.bleSetScanFilterDeviceName(
self.adv_ad.droid.bluetoothGetLocalName())
self.scn_ad.droid.bleBuildScanFilter(filter_list)
self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings,
scan_callback)
try:
event_info = self.scn_ad.ed.pop_event(expected_event_name,
self.default_timeout)
except Empty as error:
self.log.error("Could not find initial advertisement.")
return False
mac_address = event_info['data']['Result']['deviceInfo']['address']
self.log.info(
"Filter advertisement with address {}".format(mac_address))
self.scn_ad.droid.bleStopBleScan(scan_callback)
self.scn_ad.droid.bleSetScanSettingsScanMode(
ble_scan_settings_modes['low_latency'])
self.scn_ad.droid.bleSetScanFilterDeviceAddress(mac_address)
filter_list2, scan_settings2, scan_callback2 = (
generate_ble_scan_objects(self.scn_ad.droid))
self.scn_ad.droid.bleBuildScanFilter(filter_list2)
self.scn_ad.droid.bleStartBleScan(filter_list2, scan_settings2,
scan_callback2)
expected_event_name = scan_result.format(scan_callback2)
found_event = self.scn_ad.ed.pop_event(expected_event_name,
self.default_timeout)
if (found_event['data']['Result']['deviceInfo']['address'] !=
mac_address):
test_result = False
self.scn_ad.droid.bleStopBleScan(scan_callback2)
self.adv_ad.droid.bleStopBleAdvertising(advertise_callback)
return test_result
