1#/usr/bin/env python3.4 2# 3# Copyright (C) 2016 The Android Open Source Project 4# 5# Licensed under the Apache License, Version 2.0 (the "License"); you may not 6# use this file except in compliance with the License. You may obtain a copy of 7# the License at 8# 9# http://www.apache.org/licenses/LICENSE-2.0 10# 11# Unless required by applicable law or agreed to in writing, software 12# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 13# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 14# License for the specific language governing permissions and limitations under 15# the License. 16 17import itertools as it 18import pprint 19import time 20 21from queue import Empty 22from acts.test_utils.bt.BluetoothBaseTest import BluetoothBaseTest 23from acts.test_utils.bt.BleEnum import AdvertiseSettingsAdvertiseMode 24from acts.test_utils.bt.BleEnum import AdvertiseSettingsAdvertiseTxPower 25from acts.test_utils.bt.BleEnum import JavaInteger 26from acts.test_utils.bt.BleEnum import ScanSettingsScanMode 27from acts.test_utils.bt.BleEnum import ScanSettingsScanMode 28from acts.test_utils.bt.bt_test_utils import adv_fail 29from acts.test_utils.bt.bt_test_utils import adv_succ 30from acts.test_utils.bt.bt_test_utils import generate_ble_advertise_objects 31from acts.test_utils.bt.bt_test_utils import reset_bluetooth 32from acts.test_utils.bt.bt_test_utils import scan_result 33 34 35class FilteringTest(BluetoothBaseTest): 36 default_timeout = 30 37 38 valid_filter_suite = [ 39 { 40 'include_tx_power_level': True 41 }, 42 { 43 'filter_device_address': True 44 }, 45 { 46 'manufacturer_specific_data_id': 1, 47 'manufacturer_specific_data': "1" 48 }, 49 { 50 'manufacturer_specific_data_id': 1, 51 'manufacturer_specific_data': "14,0,54,0,0,0,0,0" 52 }, 53 { 54 'manufacturer_specific_data_id': 1, 55 'manufacturer_specific_data': "1", 56 'manufacturer_specific_data_mask': "1" 57 }, 58 { 59 'service_data_uuid': "0000110A-0000-1000-8000-00805F9B34FB", 60 'service_data': "1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,26,17,18,19," 61 "20,21,22,23,24" 62 }, 63 { 64 'service_data_uuid': "0000110B-0000-1000-8000-00805F9B34FB", 65 'service_data': "13" 66 }, 67 { 68 'service_data_uuid': "0000110C-0000-1000-8000-00805F9B34FB", 69 'service_data': "11,14,50" 70 }, 71 { 72 'service_data_uuid': "0000110D-0000-1000-8000-00805F9B34FB", 73 'service_data': "16,22,11" 74 }, 75 { 76 'service_data_uuid': "0000110E-0000-1000-8000-00805F9B34FB", 77 'service_data': "2,9,54" 78 }, 79 { 80 'service_data_uuid': "0000110F-0000-1000-8000-00805F9B34FB", 81 'service_data': "69,11,50" 82 }, 83 { 84 'service_data_uuid': "00001101-0000-1000-8000-00805F9B34FB", 85 'service_data': "12,11,21" 86 }, 87 { 88 'service_data_uuid': "00001102-0000-1000-8000-00805F9B34FB", 89 'service_data': "12,12,44" 90 }, 91 { 92 'service_data_uuid': "00001103-0000-1000-8000-00805F9B34FB", 93 'service_data': "4,54,1" 94 }, 95 { 96 'service_data_uuid': "00001104-0000-1000-8000-00805F9B34FB", 97 'service_data': "33,22,44" 98 }, 99 { 100 'service_uuid': "00000000-0000-1000-8000-00805f9b34fb", 101 'service_mask': "00000000-0000-1000-8000-00805f9b34fb", 102 }, 103 { 104 'service_uuid': "FFFFFFFF-0000-1000-8000-00805f9b34fb", 105 'service_mask': "00000000-0000-1000-8000-00805f9b34fb", 106 }, 107 { 108 'service_uuid': "3846D7A0-69C8-11E4-BA00-0002A5D5C51B", 109 'service_mask': "00000000-0000-1000-8000-00805f9b34fb", 110 }, 111 { 112 'include_device_name': True 113 }, 114 ] 115 116 valid_filter_variants = { 117 'include_tx_power_level': [True, False], 118 'manufacturer_specific_data_id': [1, 2, 65535], 119 'manufacturer_specific_data': ["1", "1,2", "127"], 120 'service_data_uuid': ["00000000-0000-1000-8000-00805f9b34fb"], 121 'service_data': ["1,2,3", "1", "127"], 122 'include_device_name': [False, True], 123 } 124 125 multi_manufacturer_specific_data_suite = { 126 'manufacturer_specific_data_list': [[(1, "1"), (2, "2"), 127 (65535, "127")]], 128 } 129 130 settings_in_effect_variants = { 131 "mode": [ 132 AdvertiseSettingsAdvertiseMode.ADVERTISE_MODE_BALANCED.value, 133 AdvertiseSettingsAdvertiseMode.ADVERTISE_MODE_LOW_LATENCY.value, 134 ], 135 "tx_power_level": [ 136 AdvertiseSettingsAdvertiseTxPower.ADVERTISE_TX_POWER_HIGH.value, 137 AdvertiseSettingsAdvertiseTxPower.ADVERTISE_TX_POWER_LOW.value, 138 AdvertiseSettingsAdvertiseTxPower.ADVERTISE_TX_POWER_ULTRA_LOW. 139 value, 140 AdvertiseSettingsAdvertiseTxPower.ADVERTISE_TX_POWER_MEDIUM.value, 141 ], 142 "is_connectable": [True, False], 143 "scan_mode": [ScanSettingsScanMode.SCAN_MODE_LOW_LATENCY.value, 144 ScanSettingsScanMode.SCAN_MODE_OPPORTUNISTIC.value, 145 ScanSettingsScanMode.SCAN_MODE_BALANCED.value, 146 ScanSettingsScanMode.SCAN_MODE_LOW_POWER.value, ] 147 } 148 149 default_callback = 1 150 default_is_connectable = True 151 default_advertise_mode = 0 152 default_tx_power_level = 2 153 154 def _get_combinations(self, t): 155 varNames = sorted(t) 156 return ([dict(zip(varNames, prod)) 157 for prod in it.product(*(t[varName] 158 for varName in varNames))]) 159 160 def __init__(self, controllers): 161 BluetoothBaseTest.__init__(self, controllers) 162 self.scn_ad = self.android_devices[0] 163 self.adv_ad = self.android_devices[1] 164 self.log.info("Scanner device model: {}".format( 165 self.scn_ad.droid.getBuildModel())) 166 self.log.info("Advertiser device model: {}".format( 167 self.adv_ad.droid.getBuildModel())) 168 169 def blescan_verify_onfailure_event_handler(self, event): 170 self.log.debug("Verifying {} event".format(adv_fail)) 171 self.log.debug(pprint.pformat(event)) 172 return event 173 174 def blescan_verify_onscanresult_event_handler(self, event, filters): 175 test_result = True 176 self.log.debug("Verifying onScanResult event: {}".format(event)) 177 callback_type = event['data']['CallbackType'] 178 if 'callback_type' in filters.keys(): 179 if filters['callback_type'] != callback_type: 180 self.log.error("Expected callback type: {}, Found callback " 181 "type: {}".format(filters['callback_type'], 182 callback_type)) 183 test_result = False 184 elif self.default_callback != callback_type: 185 self.log.error("Expected callback type: {}, Found callback type: " 186 "{}".format(self.default_callback, callback_type)) 187 test_result = False 188 if 'include_device_name' in filters.keys() and filters[ 189 'include_device_name'] is not False: 190 if event['data']['Result']['deviceName'] != filters[ 191 'include_device_name']: 192 self.log.error( 193 "Expected device name: {}, Found device name: {}" 194 .format(filters['include_device_name'], event['data'][ 195 'Result']['deviceName'])) 196 197 test_result = False 198 elif 'deviceName' in event['data']['Result'].keys(): 199 self.log.error( 200 "Device name was found when it wasn't meant to be included.") 201 test_result = False 202 if ('include_tx_power_level' in filters.keys() and filters[ 203 'include_tx_power_level'] is not False): 204 if not event['data']['Result']['txPowerLevel']: 205 self.log.error( 206 "Expected to find tx power level in event but found none.") 207 test_result = False 208 if not event['data']['Result']['rssi']: 209 self.log.error("Expected rssi in the advertisement, found none.") 210 test_result = False 211 if not event['data']['Result']['timestampNanos']: 212 self.log.error("Expected rssi in the advertisement, found none.") 213 test_result = False 214 return test_result 215 216 def bleadvertise_verify_onsuccess_handler(self, event, settings_in_effect): 217 self.log.debug("Verifying {} event".format(adv_succ)) 218 test_result = True 219 if 'is_connectable' in settings_in_effect.keys(): 220 if (event['data']['SettingsInEffect']['isConnectable'] != 221 settings_in_effect['is_connectable']): 222 self.log.error("Expected is connectable value: {}, Actual is " 223 "connectable value:".format(settings_in_effect[ 224 'is_connectable'], event['data'][ 225 'SettingsInEffect']['isConnectable'])) 226 test_result = False 227 elif (event['data']['SettingsInEffect']['isConnectable'] != 228 self.default_is_connectable): 229 self.log.error( 230 "Default value for isConnectable did not match what was found.") 231 test_result = False 232 if 'mode' in settings_in_effect.keys(): 233 if (event['data']['SettingsInEffect']['mode'] != 234 settings_in_effect['mode']): 235 self.log.error("Expected mode value: {}, Actual mode value: {}" 236 .format(settings_in_effect['mode'], event[ 237 'data']['SettingsInEffect']['mode'])) 238 test_result = False 239 elif (event['data']['SettingsInEffect']['mode'] != 240 self.default_advertise_mode): 241 self.log.error( 242 "Default value for filtering mode did not match what was " 243 "found.") 244 test_result = False 245 if 'tx_power_level' in settings_in_effect.keys(): 246 if (event['data']['SettingsInEffect']['txPowerLevel'] == 247 JavaInteger.MIN.value): 248 self.log.error("Expected tx power level was not meant to be: " 249 "{}".format(JavaInteger.MIN.value)) 250 test_result = False 251 elif (event['data']['SettingsInEffect']['txPowerLevel'] != 252 self.default_tx_power_level): 253 self.log.error( 254 "Default value for tx power level did not match what" 255 " was found.") 256 test_result = False 257 return test_result 258 259 def _magic(self, params): 260 (filters, settings_in_effect) = params 261 test_result = True 262 263 self.log.debug("Settings in effect: {}".format(pprint.pformat( 264 settings_in_effect))) 265 self.log.debug("Filters:".format(pprint.pformat(filters))) 266 if 'is_connectable' in settings_in_effect.keys(): 267 self.log.debug("Setting advertisement is_connectable to {}".format( 268 settings_in_effect['is_connectable'])) 269 self.adv_ad.droid.bleSetAdvertiseSettingsIsConnectable( 270 settings_in_effect['is_connectable']) 271 if 'mode' in settings_in_effect.keys(): 272 self.log.debug("Setting advertisement mode to {}" 273 .format(settings_in_effect['mode'])) 274 self.adv_ad.droid.bleSetAdvertiseSettingsAdvertiseMode( 275 settings_in_effect['mode']) 276 if 'tx_power_level' in settings_in_effect.keys(): 277 self.log.debug("Setting advertisement tx_power_level to {}".format( 278 settings_in_effect['tx_power_level'])) 279 self.adv_ad.droid.bleSetAdvertiseSettingsTxPowerLevel( 280 settings_in_effect['tx_power_level']) 281 filter_list = self.scn_ad.droid.bleGenFilterList() 282 if ('include_device_name' in filters.keys() and 283 filters['include_device_name'] is not False): 284 285 self.log.debug("Setting advertisement include_device_name to {}" 286 .format(filters['include_device_name'])) 287 self.adv_ad.droid.bleSetAdvertiseDataIncludeDeviceName(True) 288 filters['include_device_name'] = ( 289 self.adv_ad.droid.bluetoothGetLocalName()) 290 self.log.debug("Setting scanner include_device_name to {}".format( 291 filters['include_device_name'])) 292 self.scn_ad.droid.bleSetScanFilterDeviceName(filters[ 293 'include_device_name']) 294 else: 295 self.log.debug( 296 "Setting advertisement include_device_name to False") 297 self.adv_ad.droid.bleSetAdvertiseDataIncludeDeviceName(False) 298 if ('include_tx_power_level' in filters.keys() and filters[ 299 'include_tx_power_level'] is not False): 300 self.log.debug( 301 "Setting advertisement include_tx_power_level to True") 302 self.adv_ad.droid.bleSetAdvertiseDataIncludeTxPowerLevel(True) 303 if 'manufacturer_specific_data_id' in filters.keys(): 304 if 'manufacturer_specific_data_mask' in filters.keys(): 305 self.adv_ad.droid.bleAddAdvertiseDataManufacturerId( 306 filters['manufacturer_specific_data_id'], 307 filters['manufacturer_specific_data']) 308 self.scn_ad.droid.bleSetScanFilterManufacturerData( 309 filters['manufacturer_specific_data_id'], 310 filters['manufacturer_specific_data'], 311 filters['manufacturer_specific_data_mask']) 312 else: 313 self.adv_ad.droid.bleAddAdvertiseDataManufacturerId( 314 filters['manufacturer_specific_data_id'], 315 filters['manufacturer_specific_data']) 316 self.scn_ad.droid.bleSetScanFilterManufacturerData( 317 filters['manufacturer_specific_data_id'], 318 filters['manufacturer_specific_data']) 319 if 'service_data' in filters.keys(): 320 self.adv_ad.droid.bleAddAdvertiseDataServiceData( 321 filters['service_data_uuid'], filters['service_data']) 322 self.scn_ad.droid.bleSetScanFilterServiceData( 323 filters['service_data_uuid'], filters['service_data']) 324 if 'manufacturer_specific_data_list' in filters.keys(): 325 for pair in filters['manufacturer_specific_data_list']: 326 (manu_id, manu_data) = pair 327 self.adv_ad.droid.bleAddAdvertiseDataManufacturerId(manu_id, 328 manu_data) 329 if 'service_mask' in filters.keys(): 330 self.scn_ad.droid.bleSetScanFilterServiceUuid( 331 filters['service_uuid'].upper(), filters['service_mask']) 332 self.adv_ad.droid.bleSetAdvertiseDataSetServiceUuids([filters[ 333 'service_uuid'].upper()]) 334 elif 'service_uuid' in filters.keys(): 335 self.scn_ad.droid.bleSetScanFilterServiceUuid(filters[ 336 'service_uuid']) 337 self.adv_ad.droid.bleSetAdvertiseDataSetServiceUuids([filters[ 338 'service_uuid']]) 339 self.scn_ad.droid.bleBuildScanFilter(filter_list) 340 advertise_callback, advertise_data, advertise_settings = ( 341 generate_ble_advertise_objects(self.adv_ad.droid)) 342 if ('scan_mode' in settings_in_effect and 343 settings_in_effect['scan_mode'] != 344 ScanSettingsScanMode.SCAN_MODE_OPPORTUNISTIC.value): 345 self.scn_ad.droid.bleSetScanSettingsScanMode(settings_in_effect[ 346 'scan_mode']) 347 else: 348 self.scn_ad.droid.bleSetScanSettingsScanMode( 349 ScanSettingsScanMode.SCAN_MODE_LOW_LATENCY.value) 350 scan_settings = self.scn_ad.droid.bleBuildScanSetting() 351 scan_callback = self.scn_ad.droid.bleGenScanCallback() 352 self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings, 353 scan_callback) 354 opportunistic = False 355 scan_settings2, scan_callback2 = None, None 356 if ('scan_mode' in settings_in_effect and 357 settings_in_effect['scan_mode'] == 358 ScanSettingsScanMode.SCAN_MODE_OPPORTUNISTIC.value): 359 opportunistic = True 360 scan_settings2 = self.scn_ad.droid.bleBuildScanSetting() 361 scan_callback2 = self.scn_ad.droid.bleGenScanCallback() 362 self.scn_ad.droid.bleStartBleScan(filter_list, scan_settings2, 363 scan_callback2) 364 self.scn_ad.droid.bleSetScanSettingsScanMode( 365 ScanSettingsScanMode.SCAN_MODE_OPPORTUNISTIC.value) 366 self.adv_ad.droid.bleStartBleAdvertising( 367 advertise_callback, advertise_data, advertise_settings) 368 expected_advertise_event_name = adv_succ.format(advertise_callback) 369 self.log.debug(expected_advertise_event_name) 370 advertise_worker = self.adv_ad.ed.handle_event( 371 self.bleadvertise_verify_onsuccess_handler, 372 expected_advertise_event_name, ([settings_in_effect]), 373 self.default_timeout) 374 try: 375 test_result = advertise_worker.result(self.default_timeout) 376 except Empty as error: 377 self.log.error("Test failed with Empty error: {}".format(error)) 378 return False 379 expected_scan_event_name = scan_result.format(scan_callback) 380 worker = self.scn_ad.ed.handle_event( 381 self.blescan_verify_onscanresult_event_handler, 382 expected_scan_event_name, ([filters]), self.default_timeout) 383 try: 384 finished = False 385 start_time = time.time() 386 while (time.time() < start_time + self.default_timeout and 387 not finished): 388 389 test_result = worker.result(self.default_timeout) 390 if test_result: 391 finished = True 392 except Empty as error: 393 test_result = False 394 self.log.error("No scan result found: {}".format(error)) 395 if opportunistic: 396 expected_scan_event_name = scan_result.format(scan_callback2) 397 worker = self.scn_ad.ed.handle_event( 398 self.blescan_verify_onscanresult_event_handler, 399 expected_scan_event_name, ([filters]), self.default_timeout) 400 try: 401 worker.result(self.default_timeout) 402 except Empty: 403 self.log.error("Failure to find event on opportunistic scan.") 404 self.scn_ad.droid.bleStopBleScan(scan_callback2) 405 self.adv_ad.droid.bleStopBleAdvertising(advertise_callback) 406 self.scn_ad.droid.bleStopBleScan(scan_callback) 407 return test_result 408 409 @BluetoothBaseTest.bt_test_wrap 410 def test_default_advertisement(self): 411 """Test a default advertisement. 412 413 Test that a default advertisement is found and matches corresponding 414 settings. 415 416 Steps: 417 1. Create a advertise data object 418 2. Create a advertise settings object. 419 3. Create a advertise callback object. 420 4. Start an LE advertising using the objects created in steps 1-3. 421 5. Find the onSuccess advertisement event. 422 423 Expected Result: 424 Advertisement is successfully advertising. 425 426 Returns: 427 Pass if True 428 Fail if False 429 430 TAGS: LE, Advertising, Filtering, Scanning 431 Priority: 2 432 """ 433 filters = {} 434 settings_in_effect = {} 435 params = (filters, settings_in_effect) 436 return self._magic(params) 437 438 @BluetoothBaseTest.bt_test_wrap 439 def test_settings_in_effect_suite(self): 440 """Test combinations of settings with scanning and advertising. 441 442 Test combinations of valid advertising modes, tx power, is connectable, 443 and scan modes. 444 445 Steps: 446 1. Generate testcases of the combination of settings_in_effect_variants 447 dictionary. This involves setting scan settings and advertising 448 settings. 449 450 Expected Result: 451 Scan filters match advertising settings and advertisements are found. 452 453 Returns: 454 Pass if True 455 Fail if False 456 457 TAGS: LE, Advertising, Filtering, Scanning 458 Priority: 1 459 """ 460 settings = self._get_combinations(self.settings_in_effect_variants) 461 filters = [{"include_device_name": True}] 462 params = list(it.product(filters, settings)) 463 failed = self.run_generated_testcases(self._magic, 464 params, 465 tag="settings_in_effect_suite") 466 if failed: 467 return False 468 return True 469 470 @BluetoothBaseTest.bt_test_wrap 471 def test_filters_suite(self): 472 """Test combinations of settings with scanning and advertising. 473 474 Test combinations of valid advertisement data and scan settings. 475 476 Steps: 477 1. Generate testcases of the combination of valid_filter_variants and 478 settings dictionaries. This involves setting scan settings and 479 advertising settings. 480 481 Expected Result: 482 Scan filters match advertising settings and advertisements are found. 483 484 Returns: 485 Pass if True 486 Fail if False 487 488 TAGS: LE, Advertising, Filtering, Scanning 489 Priority: 1 490 """ 491 valid_filter_suit = self._get_combinations(self.valid_filter_variants) 492 settings = [ 493 {'mode': 494 AdvertiseSettingsAdvertiseMode.ADVERTISE_MODE_LOW_LATENCY.value} 495 ] 496 params = list(it.product(valid_filter_suit, settings)) 497 failed = self.run_generated_testcases(self._magic, 498 params, 499 tag="filters_suite") 500 if failed: 501 return False 502 return True 503 504 @BluetoothBaseTest.bt_test_wrap 505 def test_filters_suite_opportunistic_scan(self): 506 """Test combinations of settings with opportunistic scanning. 507 508 Test combinations of valid advertisement data and scan settings. This 509 emphasises scan mode opportunistic. 510 511 Steps: 512 1. Generate testcases of the combination of valid_filter_suite and 513 settings dictionaries. This involves setting scan settings and 514 advertising settings. 515 516 Expected Result: 517 Scan filters match advertising settings and advertisements are found. 518 519 Returns: 520 Pass if True 521 Fail if False 522 523 TAGS: LE, Advertising, Filtering, Scanning, Opportunistic Scan 524 Priority: 1 525 """ 526 reset_bluetooth(self.android_devices) 527 valid_filter_suit = self._get_combinations(self.valid_filter_variants) 528 settings = [ 529 {'mode': 530 AdvertiseSettingsAdvertiseMode.ADVERTISE_MODE_LOW_LATENCY.value, 531 'scan_mode': ScanSettingsScanMode.SCAN_MODE_LOW_LATENCY.value} 532 ] 533 params = list(it.product(valid_filter_suit, settings)) 534 failed = self.run_generated_testcases(self._magic, 535 params, 536 tag="filters_suite") 537 if failed: 538 return False 539 return True 540 541 @BluetoothBaseTest.bt_test_wrap 542 def test_valid_filters(self): 543 """Test combinations of settings with scanning and advertising. 544 545 Test combinations of valid advertisement data and scan settings. 546 547 Steps: 548 1. Generate testcases of the combination of valid_filters and 549 settings dictionaries. This involves setting scan settings and 550 advertising settings. 551 552 Expected Result: 553 Scan filters match advertising settings and advertisements are found. 554 555 Returns: 556 Pass if True 557 Fail if False 558 559 TAGS: LE, Advertising, Filtering, Scanning 560 Priority: 1 561 """ 562 reset_bluetooth(self.android_devices) 563 settings = [ 564 {'mode': 565 AdvertiseSettingsAdvertiseMode.ADVERTISE_MODE_LOW_LATENCY.value} 566 ] 567 params = list(it.product(self.valid_filter_suite, settings)) 568 failed = self.run_generated_testcases(self._magic, 569 params, 570 tag="valid_filters") 571 if failed: 572 return False 573 return True 574 575 @BluetoothBaseTest.bt_test_wrap 576 def test_valid_filters_opportunistic_scan(self): 577 """Test combinations of settings with opportunistic scanning. 578 579 Test combinations of valid advertisement data and scan settings. This 580 emphasises scan mode opportunistic. 581 582 Steps: 583 1. Generate testcases of the combination of valid_filter_suite and 584 settings dictionaries. This involves setting scan settings and 585 advertising settings. 586 587 Expected Result: 588 Scan filters match advertising settings and advertisements are found. 589 590 Returns: 591 Pass if True 592 Fail if False 593 594 TAGS: LE, Advertising, Filtering, Scanning, Opportunistic Scan 595 Priority: 1 596 """ 597 settings = [ 598 {'mode': 599 AdvertiseSettingsAdvertiseMode.ADVERTISE_MODE_LOW_LATENCY.value, 600 'scan_mode': ScanSettingsScanMode.SCAN_MODE_LOW_LATENCY.value} 601 ] 602 params = list(it.product(self.valid_filter_suite, settings)) 603 failed = self.run_generated_testcases(self._magic, 604 params, 605 tag="valid_filters") 606 if failed: 607 return False 608 return True 609 610 @BluetoothBaseTest.bt_test_wrap 611 def test_non_connectable_advertise_data(self): 612 """Test non connectable advertisement data. 613 614 Non-connectable advertisement data does not include the AD flags in 615 the advertisement giving back more data to the overall advertisement 616 data size. 617 618 Steps: 619 1. Create a large advertisement data object. 620 2. Set isConnectable to false. 621 3. Build advertising objects. 622 4. Start scanning. 623 5. Start advertising. 624 6. Find advertisement and verify data. 625 626 Expected Result: 627 Scan filters match advertising settings and advertisements are found. 628 629 Returns: 630 Pass if True 631 Fail if False 632 633 TAGS: LE, Advertising, Filtering, Scanning 634 Priority: 1 635 """ 636 settings = {'is_connectable': False} 637 filters = { 638 'service_data_uuid': "0000110A-0000-1000-8000-00805F9B34FB", 639 'service_data': "1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,26,17,18,19," 640 "20,21,22,23,24,25,26,27", 641 } 642 params = (filters, settings) 643 return self._magic(params) 644