def test_batch_scan_result_not_expected(self):
"""Test opportunistic batch scan without expecting an event.
Tests opportunistic scan where it will only report scan results when
other registered scanners find results. Set the report delay millis such
that a batch scan is not expected.
Steps:
1. Initialize advertiser and start advertisement on dut1
2. Initialize scanner with scan mode set to opportunistic mode and
set scan settings report delay seconds such that a batch scan is
expected.
3. Start scanning on dut 0
4. Try to find an event, expect none.
5. Start a second scanner on dut0, with any other mode set and set scan
settings report delay millis to 0 such that an onBatchScanResult is not
expected.
6. Pop onScanResults event on the second scanner
7. Pop onBatchScanResult event on the first scanner
Expected Result:
Batch scan result is not expected on opportunistic scan instance.
Returns:
Pass if True
Fail if False
TAGS: LE, Advertising, Scanning, Opportunistic Scan, Batch Scanning
Priority: 1
"""
self._setup_generic_advertisement()
self.scn_ad.droid.bleSetScanSettingsScanMode(
ble_scan_settings_modes['opportunistic'])
self.scn_ad.droid.bleSetScanSettingsReportDelayMillis(
self.report_delay)
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)
self.active_scan_callback_list.append(scan_callback)
if not self._verify_no_events_found(
batch_scan_result.format(scan_callback)):
return False
self.scn_ad.droid.bleSetScanSettingsScanMode(
ble_scan_settings_modes['low_latency'])
filter_list2, scan_settings2, scan_callback2 = (
generate_ble_scan_objects(self.scn_ad.droid))
self.scn_ad.droid.bleStartBleScan(filter_list2, scan_settings2,
scan_callback2)
self.active_scan_callback_list.append(scan_callback2)
try:
self.scn_ad.ed.pop_event(scan_result.format(scan_callback2),
self.default_timeout)
except Empty:
self.log.error("Non-Opportunistic scan found no scan results.")
return False
return self._verify_no_events_found(
batch_scan_result.format(scan_callback))
def test_max_opportunistic_batch_scan_instances(self):
"""Test max opportunistic batch scan instances.
Tests max instances of opportunistic batch scans. Each instances should
find an onBatchScanResult event.
Steps:
1. Initialize advertiser and start advertisement on dut1
2. Set scan settings to opportunistic scan on dut0 scan instance and
set report delay seconds such that an onBatchScanResult is expected
3. Start scan scan from step 2
4. Repeat step two and three until there are max_scan_instances-1 scan
instances
5. Start a regular ble scan on dut0 with the last available scan
instance
6. Pop onBatchScanResult event on all scan instances
Expected Result:
Each opportunistic scan instance finds an advertisement.
Returns:
Pass if True
Fail if False
TAGS: LE, Advertising, Scanning, Opportunistic Scan, Batch Scanning
Priority: 1
"""
self._setup_generic_advertisement()
for _ in range(self.max_scan_instances - 1):
self.scn_ad.droid.bleSetScanSettingsScanMode(
ble_scan_settings_modes['opportunistic'])
self.scn_ad.droid.bleSetScanSettingsReportDelayMillis(
self.report_delay)
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)
self.active_scan_callback_list.append(scan_callback)
self.scn_ad.droid.bleSetScanSettingsScanMode(
ble_scan_settings_modes['low_latency'])
self.scn_ad.droid.bleSetScanSettingsReportDelayMillis(
self.report_delay)
filter_list2, scan_settings2, scan_callback2 = (
generate_ble_scan_objects(self.scn_ad.droid))
self.scn_ad.droid.bleStartBleScan(filter_list2, scan_settings2,
scan_callback2)
self.active_scan_callback_list.append(scan_callback2)
for callback in self.active_scan_callback_list:
try:
self.scn_ad.ed.pop_event(batch_scan_result.format(callback),
self.default_timeout)
except Empty:
self.log.error(
"No scan results found for callback {}".format(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.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_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)
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)
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_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 test_batch_scan_result_no_advertisement(self):
"""Test batch opportunistic scan without an advertisement.
Tests opportunistic scan where there are no advertisements. This should
not find any onBatchScanResult.
Steps:
1. Initialize scanner with scan mode set to opportunistic mode.
2. Set report delay seconds such that onBatchScanResult events are
expected
2. Start scanning on dut 0
3. Pop onBatchScanResult event on the scanner
Expected Result:
Find no advertisements with the opportunistic scan instance.
Returns:
Pass if True
Fail if False
TAGS: LE, Advertising, Scanning, Opportunistic Scan, Batch Scanning
Priority: 1
"""
self.scn_ad.droid.bleSetScanSettingsScanMode(
ble_scan_settings_modes['opportunistic'])
self.scn_ad.droid.bleSetScanSettingsReportDelayMillis(
self.report_delay)
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)
self.active_scan_callback_list.append(scan_callback)
if not self._verify_no_events_found(
batch_scan_result.format(scan_callback)):
return False
self.scn_ad.droid.bleStopBleScan(scan_callback)
return True
