def test_scan_filtering_multiple_advertisements_manufacturer_data(self): """Test scan filtering against multiple varying advertisements. Test scan filtering against multiple varying advertisements. The first advertisement will have partial manufacturer data that matches the the full manufacturer data in the second advertisement. Steps: 1. Setup up an advertisement with manufacturer data [1,2,3]. 2. Setup a second advertisement with manufacturer data [1,2,3,4,5,6,7,8]. 3. Start advertising on each advertisement. 4. Create a scan filter that includes manufacturer data [1,2,3]. Expected Result: TBD. Right now Shamu finds only the first advertisement with manufacturer data [1,2,3]. Returns: Pass if True Fail if False TAGS: LE, Advertising, Filtering, Scanning Priority: 2 """ test_result = True self.adv_ad.droid.bleSetAdvertiseSettingsAdvertiseMode( ble_advertise_settings_modes['low_latency']) self.adv_ad.droid.bleAddAdvertiseDataManufacturerId(117, [1, 2, 3]) advertise_callback, advertise_data, advertise_settings = ( generate_ble_advertise_objects(self.adv_ad.droid)) self.adv_ad.droid.bleSetAdvertiseSettingsAdvertiseMode( ble_advertise_settings_modes['low_latency']) self.adv_ad.droid.bleAddAdvertiseDataManufacturerId( 117, [1, 2, 3, 4, 5, 6, 7, 8]) advertise_callback1, advertise_data1, advertise_settings1 = ( generate_ble_advertise_objects(self.adv_ad.droid)) self.adv_ad.droid.bleStartBleAdvertising(advertise_callback, advertise_data, advertise_settings) self.adv_ad.droid.bleStartBleAdvertising(advertise_callback1, advertise_data1, advertise_settings1) filter_list = self.scn_ad.droid.bleGenFilterList() self.scn_ad.droid.bleSetScanSettingsScanMode( ble_scan_settings_modes['low_latency']) scan_settings = self.scn_ad.droid.bleBuildScanSetting() scan_callback = self.scn_ad.droid.bleGenScanCallback() self.scn_ad.droid.bleSetScanFilterManufacturerData( 117, [1, 2, 3], [127, 127, 127]) self.scn_ad.droid.bleBuildScanFilter(filter_list) self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings, scan_callback) return test_result
def start_max_advertisements(self, line): scan_response = None if line: scan_response = bool(line) while (True): try: self.dut.droid.bleSetAdvertiseSettingsAdvertiseMode( ble_advertise_settings_modes['low_latency']) self.dut.droid.bleSetAdvertiseSettingsIsConnectable(True) advertise_callback, advertise_data, advertise_settings = ( generate_ble_advertise_objects(self.dut.droid)) if scan_response: self.dut.droid.bleStartBleAdvertisingWithScanResponse( advertise_callback, advertise_data, advertise_settings, advertise_data) else: self.dut.droid.bleStartBleAdvertising( advertise_callback, advertise_data, advertise_settings) if self._verify_ble_adv_started(advertise_callback): self.log.info( "Tracking Callback ID: {}".format(advertise_callback)) self.advertisement_list.append(advertise_callback) self.log.info(self.advertisement_list) else: self.log.info("Advertisements active: {}".format( len(self.advertisement_list))) return False except Exception as err: self.log.info("Advertisements active: {}".format( len(self.advertisement_list))) return True
def _setup_generic_advertisement(self): self.adv_ad.droid.bleSetAdvertiseDataIncludeDeviceName(True) adv_callback, adv_data, adv_settings = generate_ble_advertise_objects( self.adv_ad.droid) self.adv_ad.droid.bleStartBleAdvertising(adv_callback, adv_data, adv_settings) self.active_adv_callback_list.append(adv_callback)
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 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_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_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 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_timeout(self): """Test starting advertiser with timeout. Test that when a timeout is used, the advertiser is cleaned properly, and next one can be started. Steps: 1. Setup the advertiser android device with 4 second timeout. 2. Call start ble advertising. 3. Wait 5 seconds, to make sure advertiser times out. 4. Repeat steps 1-4 four times. Expected Result: Starting the advertising should succeed each time. Returns: Pass if True Fail if False TAGS: LE, Advertising, Concurrency Priority: 1 """ advertise_timeout_s = 4 num_iterations = 4 test_result = True for i in range(0, num_iterations): advertise_callback, advertise_data, advertise_settings = ( generate_ble_advertise_objects(self.adv_ad.droid)) self.adv_ad.droid.bleSetAdvertiseSettingsTimeout( advertise_timeout_s * 1000) 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)) if not test_result: return test_result time.sleep(advertise_timeout_s + 1) return test_result
def test_start_two_advertisements_on_same_callback(self): """Test invalid advertisement scenario. Test that a single device cannot have two advertisements start on the same callback. Steps: 1. Setup the scanning android device. 2. Setup the advertiser android device. 3. Call start ble advertising on the same callback. Expected Result: The second call of start advertising on the same callback 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)) return False except concurrent.futures._base.TimeoutError as error: self.log.debug( "Test failed, filtering callback onSuccess never occurred: {}". format(error)) try: self.adv_ad.droid.bleStartBleAdvertising(advertise_callback, advertise_data, advertise_settings) self.adv_ad.ed.pop_event(adv_succ.format(advertise_callback), self.default_timeout) test_result = False except Empty as error: self.log.debug("Test passed with Empty error: {}".format(error)) except concurrent.futures._base.TimeoutError as error: self.log.debug( "Test passed, filtering callback onSuccess never occurred: {}". format(error)) return test_result
def _setup_generic_advertisement(self): self.adv_ad.droid.bleSetAdvertiseSettingsAdvertiseMode( ble_advertise_settings_modes['low_latency']) self.advertise_callback, advertise_data, advertise_settings = ( generate_ble_advertise_objects(self.adv_ad.droid)) self.adv_ad.droid.bleStartBleAdvertising( self.advertise_callback, advertise_data, advertise_settings) try: self.adv_ad.ed.pop_event(adv_succ.format(self.advertise_callback)) except Empty: self.log.error("Failed to start advertisement.") return False 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 start_generic_nonconnectable_advertisement(self, line): """Start a nonconnectable LE advertisement""" self.dut.droid.bleSetAdvertiseSettingsAdvertiseMode( ble_advertise_settings_modes['low_latency']) self.dut.droid.bleSetAdvertiseSettingsIsConnectable(False) advertise_callback, advertise_data, advertise_settings = ( generate_ble_advertise_objects(self.dut.droid)) self.dut.droid.bleStartBleAdvertising( advertise_callback, advertise_data, advertise_settings) if self._verify_ble_adv_started(advertise_callback): self.log.info("Tracking Callback ID: {}".format( advertise_callback)) self.advertisement_list.append(advertise_callback) self.log.info(self.advertisement_list)
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_loop_advertising_100(self): """Stress start/stop advertising instances. This test will start and stop advertising instances as fast as possible. Steps: 1. Start a advertising instance. 2. Find that an onSuccess callback is triggered. 3. Stop the advertising instance. 4. Repeat steps 1-3 100 times. Expected Result: Neither starting or stopping advertising instances causes any failures. Returns: Pass if True Fail if False TAGS: LE, Advertising, Stress Priority: 1 """ test_result = True for _ in range(100): 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 = False self.adv_ad.droid.bleStopBleAdvertising(advertise_callback) return test_result
def start_generic_connectable_advertisement(self, line): """Start a connectable LE advertisement""" scan_response = None if line: scan_response = bool(line) self.dut.droid.bleSetAdvertiseSettingsAdvertiseMode( ble_advertise_settings_modes['low_latency']) self.dut.droid.bleSetAdvertiseSettingsIsConnectable(True) advertise_callback, advertise_data, advertise_settings = ( generate_ble_advertise_objects(self.dut.droid)) if scan_response: self.dut.droid.bleStartBleAdvertisingWithScanResponse( advertise_callback, advertise_data, advertise_settings, advertise_data) else: self.dut.droid.bleStartBleAdvertising( advertise_callback, advertise_data, advertise_settings) if self._verify_ble_adv_started(advertise_callback): self.log.info("Tracking Callback ID: {}".format( advertise_callback)) self.advertisement_list.append(advertise_callback) self.log.info(self.advertisement_list)
def test_advertisement_greater_than_31_bytes(self): """Tests advertisement data's size to be greater than 31 bytes. This advertisement data from "set" advertisement manufacturers data should match the corresponding "get" function. Steps: 1. Build a new AdvertiseData object. 2. Set the AdvertiseData's size to be greater than 31 bytes 3. Build the advertisement data. Expected Result: Api fails to build the AdvertiseData. Returns: True is pass False if fail TAGS: LE, Advertising Priority: 1 """ test_result = True droid = self.ad_dut.droid ed = self.android_devices[0].ed service_data = [] for i in range(25): service_data.append(i) droid.bleAddAdvertiseDataServiceData( "0000110D-0000-1000-8000-00805F9B34FB", service_data) advcallback, adv_data, adv_settings = generate_ble_advertise_objects( droid) droid.bleStartBleAdvertising(advcallback, adv_data, adv_settings) try: ed.pop_event(adv_fail.format(advcallback)) except rpc_client.Sl4aApiError: self.log.info("{} event was not found.".format( adv_fail.format(advcallback))) return False return test_result
def test_loop_scanning_100_verify_no_hci_timeout(self): """Stress start/stop scan instances variant. This test will start and stop scan instances with a one second timeout in between each iteration. This testcase was added because the specific timing combination caused hci timeouts. Steps: 1. Start a scan instance. 2. Stop the scan instance. 3. Sleep for 1 second. 4. Repeat steps 1-3 100 times. Expected Result: Neither starting or stopping scan instances causes any failures. Returns: Pass if True Fail if False TAGS: LE, Scanning, Stress Priority: 1 """ for _ in range(self.droid_list[1]['max_advertisements']): adv_callback, adv_data, adv_settings = generate_ble_advertise_objects( self.adv_ad.droid) self.adv_ad.droid.bleStartBleAdvertising(adv_callback, adv_data, adv_settings) for _ in range(100): 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.log.info( self.scn_ad.ed.pop_event(scan_result.format(scan_callback))) self.scn_ad.droid.bleStopBleScan(scan_callback) time.sleep(1) return True
def test_max_concurrent_ble_scans_verify_scans_stop_independently(self): """Test max LE scans variant. Test that a single device can have max scans concurrently scanning. Steps: 1. Initialize scanner 2. Initialize advertiser 3. Create max ble scan callbacks 4. Start ble scan on each callback 5. Start advertising on the device from step 2 6. Verify that the first callback triggers 7. Stop the scan and repeat steps 6 and 7 until all scans stopped Expected Result: All scanning instances should start without errors and the advertisement should be found on each scan instance. All scanning instances should stop successfully. Returns: Pass if True Fail if False TAGS: LE, Scanning, Concurrency Priority: 1 """ self.adv_ad.droid.bleSetAdvertiseDataIncludeDeviceName(True) self.scn_ad.droid.bleSetScanSettingsCallbackType( ScanSettingsCallbackType.CALLBACK_TYPE_ALL_MATCHES.value) self.scn_ad.droid.bleSetScanSettingsScanMode( ScanSettingsScanMode.SCAN_MODE_LOW_LATENCY.value) self.adv_ad.droid.bleSetAdvertiseSettingsAdvertiseMode( AdvertiseSettingsAdvertiseMode.ADVERTISE_MODE_LOW_LATENCY.value) advertise_callback, advertise_data, advertise_settings = ( generate_ble_advertise_objects(self.adv_ad.droid)) filter_list = self.scn_ad.droid.bleGenFilterList() self.scn_ad.droid.bleSetScanFilterDeviceName( self.adv_ad.droid.bluetoothGetLocalName()) self.scn_ad.droid.bleBuildScanFilter(filter_list) scan_settings = self.scn_ad.droid.bleBuildScanSetting() scan_callback_list = [] for i in range(self.max_concurrent_scans): self.log.debug("Concurrent Ble Scan iteration {}".format(i + 1)) scan_callback = self.scn_ad.droid.bleGenScanCallback() scan_callback_list.append(scan_callback) self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings, scan_callback) 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.exception( "Test failed with Empty error: {}".format(error)) return False except concurrent.futures._base.TimeoutError as error: self.log.exception( "Test failed, filtering callback onSuccess never" " occurred: {}".format(error)) return False i = 0 for callback in scan_callback_list: expected_scan_event_name = scan_result.format(scan_callback) try: self.scn_ad.ed.pop_event(expected_scan_event_name, self.default_timeout) self.log.info( "Found scan event successfully. Iteration {} successful.". format(i)) i += 1 except Exception: self.log.info( "Failed to find a scan result for callback {}".format( scan_callback)) return False self.scn_ad.droid.bleStopBleScan(callback) self.adv_ad.droid.bleStopBleAdvertising(advertise_callback) return True
def _setup_generic_advertisement(self): adv_callback, adv_data, adv_settings = generate_ble_advertise_objects( self.adv_ad.droid) self.adv_ad.droid.bleStartBleAdvertising(adv_callback, adv_data, adv_settings) self.active_adv_callback_list.append(adv_callback)
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
def _magic(self, params): (filters, settings_in_effect) = params test_result = True self.log.debug("Settings in effect: {}".format(pprint.pformat( settings_in_effect))) self.log.debug("Filters:".format(pprint.pformat(filters))) if 'is_connectable' in settings_in_effect.keys(): self.log.debug("Setting advertisement is_connectable to {}".format( settings_in_effect['is_connectable'])) self.adv_ad.droid.bleSetAdvertiseSettingsIsConnectable( settings_in_effect['is_connectable']) if 'mode' in settings_in_effect.keys(): self.log.debug("Setting advertisement mode to {}" .format(settings_in_effect['mode'])) self.adv_ad.droid.bleSetAdvertiseSettingsAdvertiseMode( settings_in_effect['mode']) if 'tx_power_level' in settings_in_effect.keys(): self.log.debug("Setting advertisement tx_power_level to {}".format( settings_in_effect['tx_power_level'])) self.adv_ad.droid.bleSetAdvertiseSettingsTxPowerLevel( settings_in_effect['tx_power_level']) filter_list = self.scn_ad.droid.bleGenFilterList() if ('include_device_name' in filters.keys() and filters['include_device_name'] is not False): self.log.debug("Setting advertisement include_device_name to {}" .format(filters['include_device_name'])) self.adv_ad.droid.bleSetAdvertiseDataIncludeDeviceName(True) filters['include_device_name'] = ( self.adv_ad.droid.bluetoothGetLocalName()) self.log.debug("Setting scanner include_device_name to {}".format( filters['include_device_name'])) self.scn_ad.droid.bleSetScanFilterDeviceName(filters[ 'include_device_name']) else: self.log.debug( "Setting advertisement include_device_name to False") self.adv_ad.droid.bleSetAdvertiseDataIncludeDeviceName(False) if ('include_tx_power_level' in filters.keys() and filters[ 'include_tx_power_level'] is not False): self.log.debug( "Setting advertisement include_tx_power_level to True") self.adv_ad.droid.bleSetAdvertiseDataIncludeTxPowerLevel(True) if 'manufacturer_specific_data_id' in filters.keys(): if 'manufacturer_specific_data_mask' in filters.keys(): self.adv_ad.droid.bleAddAdvertiseDataManufacturerId( filters['manufacturer_specific_data_id'], filters['manufacturer_specific_data']) self.scn_ad.droid.bleSetScanFilterManufacturerData( filters['manufacturer_specific_data_id'], filters['manufacturer_specific_data'], filters['manufacturer_specific_data_mask']) else: self.adv_ad.droid.bleAddAdvertiseDataManufacturerId( filters['manufacturer_specific_data_id'], filters['manufacturer_specific_data']) self.scn_ad.droid.bleSetScanFilterManufacturerData( filters['manufacturer_specific_data_id'], filters['manufacturer_specific_data']) if 'service_data' in filters.keys(): self.adv_ad.droid.bleAddAdvertiseDataServiceData( filters['service_data_uuid'], filters['service_data']) self.scn_ad.droid.bleSetScanFilterServiceData( filters['service_data_uuid'], filters['service_data']) if 'manufacturer_specific_data_list' in filters.keys(): for pair in filters['manufacturer_specific_data_list']: (manu_id, manu_data) = pair self.adv_ad.droid.bleAddAdvertiseDataManufacturerId(manu_id, manu_data) if 'service_mask' in filters.keys(): self.scn_ad.droid.bleSetScanFilterServiceUuid( filters['service_uuid'].upper(), filters['service_mask']) self.adv_ad.droid.bleSetAdvertiseDataSetServiceUuids([filters[ 'service_uuid'].upper()]) elif 'service_uuid' in filters.keys(): self.scn_ad.droid.bleSetScanFilterServiceUuid(filters[ 'service_uuid']) self.adv_ad.droid.bleSetAdvertiseDataSetServiceUuids([filters[ 'service_uuid']]) self.scn_ad.droid.bleBuildScanFilter(filter_list) advertise_callback, advertise_data, advertise_settings = ( generate_ble_advertise_objects(self.adv_ad.droid)) if ('scan_mode' in settings_in_effect and settings_in_effect['scan_mode'] != ScanSettingsScanMode.SCAN_MODE_OPPORTUNISTIC.value): self.scn_ad.droid.bleSetScanSettingsScanMode(settings_in_effect[ 'scan_mode']) else: self.scn_ad.droid.bleSetScanSettingsScanMode( ScanSettingsScanMode.SCAN_MODE_LOW_LATENCY.value) scan_settings = self.scn_ad.droid.bleBuildScanSetting() scan_callback = self.scn_ad.droid.bleGenScanCallback() self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings, scan_callback) opportunistic = False scan_settings2, scan_callback2 = None, None if ('scan_mode' in settings_in_effect and settings_in_effect['scan_mode'] == ScanSettingsScanMode.SCAN_MODE_OPPORTUNISTIC.value): opportunistic = True scan_settings2 = self.scn_ad.droid.bleBuildScanSetting() scan_callback2 = self.scn_ad.droid.bleGenScanCallback() self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings2, scan_callback2) self.scn_ad.droid.bleSetScanSettingsScanMode( ScanSettingsScanMode.SCAN_MODE_OPPORTUNISTIC.value) self.adv_ad.droid.bleStartBleAdvertising( advertise_callback, advertise_data, advertise_settings) expected_advertise_event_name = adv_succ.format(advertise_callback) self.log.debug(expected_advertise_event_name) try: event = self.adv_ad.ed.pop_event(expected_advertise_event_name, self.default_timeout) except Empty: self.log.error("Failed to start advertisement.") return False if not self._bleadvertise_verify_onsuccess(event, settings_in_effect): return False expected_scan_event_name = scan_result.format(scan_callback) try: event = self.scn_ad.ed.pop_event(expected_scan_event_name, self.default_timeout) except Empty: self.log.error("Scan event not found: {}".format(expected_scan_event_name)) return False if not self._blescan_verify_onscanresult_event(event, filters): return False if opportunistic: expected_scan_event_name = scan_result.format(scan_callback2) try: event = self.scn_ad.ed.pop_event(expected_scan_event_name, self.default_timeout) except Empty: self.log.error("Opportunistic scan event not found: {}".format(expected_scan_event_name)) return False if not self._blescan_verify_onscanresult_event(event, filters): return False self.scn_ad.droid.bleStopBleScan(scan_callback2) self.adv_ad.droid.bleStopBleAdvertising(advertise_callback) self.scn_ad.droid.bleStopBleScan(scan_callback) return test_result
def test_filter_manufacturer_id_bounds(self): """Test scan filtering of lower and upper bounds of allowed manu data This test will setup one Android device as an advertiser and the second as the scanner and test the upper and lower bounds of manufacturer data filtering Steps: 1. Start an advertisement with manufacturer id set to 0x004c 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 """ manufacturer_id_list = [0, 1, 65534, 65535] for manufacturer_id in manufacturer_id_list: self.adv_ad.droid.bleAddAdvertiseDataManufacturerId( manufacturer_id, [0x01]) self.adv_ad.droid.bleSetAdvertiseSettingsAdvertiseMode( ble_advertise_settings_modes['low_latency']) 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_event = adv_succ.format(advertise_callback) try: self.adv_ad.ed.pop_event(expected_event) except Empty: self.log.info("Failed to start advertisement.") return False self.scn_ad.droid.bleSetScanSettingsScanMode( ble_scan_settings_modes['low_latency']) self.scn_ad.droid.bleSetScanFilterManufacturerData( manufacturer_id, [0x01]) filter_list = self.scn_ad.droid.bleGenFilterList() scan_settings = self.scn_ad.droid.bleBuildScanSetting() scan_filter = self.scn_ad.droid.bleBuildScanFilter(filter_list) scan_callback = self.scn_ad.droid.bleGenScanCallback() self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings, scan_callback) expected_event_name = scan_result.format(scan_callback) event = None try: event = self.scn_ad.ed.pop_event(expected_event_name, self.default_timeout) except Empty: self.log.error("Unable to find beacon advertisement.") return False found_manufacturer_id = json.loads( event['data']['Result']['manufacturerIdList']) if found_manufacturer_id[0] != manufacturer_id: self.log.error( "Manufacturer id mismatch. Found {}, Expected {}".format( found_manufacturer_id, manufacturer_id)) return False self.scn_ad.droid.bleStopBleScan(scan_callback) self.adv_ad.droid.bleStopBleAdvertising(advertise_callback) 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 test_max_concurrent_ble_scans(self): """Test max LE scans. Test that a single device can have max scans concurrently scanning. Steps: 1. Initialize scanner 2. Initialize advertiser 3. Start advertising on the device from step 2 4. Create max ble scan callbacks 5. Start ble scan on each callback 6. Verify that each callback triggers 7. Stop all scans and advertisements Expected Result: All scanning instances should start without errors and the advertisement should be found on each scan instance. Returns: Pass if True Fail if False TAGS: LE, Scanning, Concurrency Priority: 0 """ test_result = True self.adv_ad.droid.bleSetAdvertiseDataIncludeDeviceName(True) self.scn_ad.droid.bleSetScanSettingsCallbackType( ScanSettingsCallbackType.CALLBACK_TYPE_ALL_MATCHES.value) self.scn_ad.droid.bleSetScanSettingsScanMode( ScanSettingsScanMode.SCAN_MODE_LOW_LATENCY.value) self.adv_ad.droid.bleSetAdvertiseSettingsAdvertiseMode( AdvertiseSettingsAdvertiseMode.ADVERTISE_MODE_LOW_LATENCY.value) advertise_callback, advertise_data, advertise_settings = ( generate_ble_advertise_objects(self.adv_ad.droid)) self.adv_ad.droid.bleSetAdvertiseSettingsIsConnectable(False) 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.exception( "Test failed with Empty error: {}".format(error)) test_result = False except concurrent.futures._base.TimeoutError as error: self.log.exception( "Test failed callback onSuccess never occurred: " "{}".format(error)) test_result = False if not test_result: return test_result filter_list = self.scn_ad.droid.bleGenFilterList() self.scn_ad.droid.bleSetScanFilterDeviceName( self.adv_ad.droid.bluetoothGetLocalName()) self.scn_ad.droid.bleBuildScanFilter(filter_list) scan_settings = self.scn_ad.droid.bleBuildScanSetting() scan_callback_list = [] for i in range(self.max_concurrent_scans): self.log.debug("Concurrent Ble Scan iteration {}".format(i + 1)) scan_callback = self.scn_ad.droid.bleGenScanCallback() scan_callback_list.append(scan_callback) 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) self.log.info("Found scan event successfully. Iteration {} " "successful.".format(i)) except Exception: self.log.info( "Failed to find a scan result for callback {}".format( scan_callback)) test_result = False break for callback in scan_callback_list: self.scn_ad.droid.bleStopBleScan(callback) self.adv_ad.droid.bleStopBleAdvertising(advertise_callback) if not test_result: return test_result self.log.info("Waiting for scan callbacks to stop completely.") # Wait for all scan callbacks to stop. There is no confirmation # otherwise. time.sleep(10) return test_result
def test_filter_simulated_ibeacon(self): """Test scan filtering of a simulated ibeacon. This test will setup one Android device as an ibeacon and a second Android device will be used to test filtering of the manufacturer data for 60 seconds. Steps: 1. Start an advertisement with manufacturer id set to 0x004c 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 """ manufacturer_id = 0x4c self.adv_ad.droid.bleAddAdvertiseDataManufacturerId( manufacturer_id, [0x01]) self.adv_ad.droid.bleSetAdvertiseSettingsAdvertiseMode( AdvertiseSettingsAdvertiseMode.ADVERTISE_MODE_LOW_LATENCY.value) 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_event = adv_succ.format(advertise_callback) try: self.adv_ad.ed.pop_event(expected_event) except Empty: self.log.info("Failed to start advertisement.") return False self.scn_ad.droid.bleSetScanSettingsScanMode( ScanSettingsScanMode.SCAN_MODE_LOW_LATENCY.value) self.scn_ad.droid.bleSetScanFilterManufacturerData( manufacturer_id, [0x01]) filter_list = self.scn_ad.droid.bleGenFilterList() scan_settings = self.scn_ad.droid.bleBuildScanSetting() scan_filter = self.scn_ad.droid.bleBuildScanFilter(filter_list) scan_callback = self.scn_ad.droid.bleGenScanCallback() self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings, scan_callback) # continuously scan for 60 seconds scan_time = 60 end_time = time.time() + scan_time expected_event_name = scan_result.format(scan_callback) event = None while time.time() < end_time: try: event = self.scn_ad.ed.pop_event(expected_event_name, self.default_timeout) found_manufacturer_id = json.loads( event['data']['Result']['manufacturerIdList']) if found_manufacturer_id[0] != manufacturer_id: self.log.error( "Manufacturer id mismatch. Found {}, Expected {}". format(found_manufacturer_id, manufacturer_id)) return False except Empty: self.log.error("Unable to find ibeacon advertisement.") return False self.scn_ad.droid.bleStopBleScan(scan_callback) self.adv_ad.droid.bleStopBleAdvertising(advertise_callback) return True
def test_max_concurrent_ble_scans_then_discover_advertisement(self): """Test max LE scans variant. Test that a single device can have max scans concurrently scanning. Steps: 1. Initialize scanner 2. Initialize advertiser 3. Create max ble scan callbacks 4. Start ble scan on each callback 5. Start advertising on the device from step 2 6. Verify that each callback triggers 7. Stop all scans and advertisements Expected Result: All scanning instances should start without errors and the advertisement should be found on each scan instance. Returns: Pass if True Fail if False TAGS: LE, Scanning, Concurrency Priority: 1 """ self.adv_ad.droid.bleSetAdvertiseDataIncludeDeviceName(True) self.scn_ad.droid.bleSetScanSettingsCallbackType( ble_scan_settings_callback_types['all_matches']) self.scn_ad.droid.bleSetScanSettingsScanMode( ble_scan_settings_modes['low_latency']) self.adv_ad.droid.bleSetAdvertiseSettingsAdvertiseMode( ble_advertise_settings_modes['low_latency']) advertise_callback, advertise_data, advertise_settings = ( generate_ble_advertise_objects(self.adv_ad.droid)) filter_list = self.scn_ad.droid.bleGenFilterList() self.scn_ad.droid.bleSetScanFilterDeviceName( self.adv_ad.droid.bluetoothGetLocalName()) self.scn_ad.droid.bleBuildScanFilter(filter_list) scan_settings = self.scn_ad.droid.bleBuildScanSetting() scan_callback_list = [] for i in range(self.max_concurrent_scans): self.log.debug("Concurrent Ble Scan iteration {}".format(i + 1)) scan_callback = self.scn_ad.droid.bleGenScanCallback() scan_callback_list.append(scan_callback) self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings, scan_callback) 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.exception( "Test failed with Empty error: {}".format(error)) return False except concurrent.futures._base.TimeoutError as error: self.log.exception("Test failed, filtering callback onSuccess " "never occurred: {}".format(error)) return False i = 0 for callback in scan_callback_list: try: self.scn_ad.ed.pop_event(scan_result.format(scan_callback), self.default_timeout) self.log.info( "Found scan event successfully. Iteration {} successful.". format(i)) except Exception: self.log.info( "Failed to find a scan result for callback {}".format( scan_callback)) return False i += 1 for callback in scan_callback_list: self.scn_ad.droid.bleStopBleScan(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