1# Copyright 2016 The Chromium OS Authors. All rights reserved. 2# Use of this source code is governed by a BSD-style license that can be 3# found in the LICENSE file. 4 5"""Server side bluetooth tests on adapter ble advertising. 6 7The Mnemonics describing the test cases: 8 CD: check advertising duration and intervals 9 RA: register advertisements 10 UA: unregister advertisements 11 SI: set advertising intervals 12 RS: reset advertising 13 FRA: fail to register extra advertisements when max ones 14 have been registered. 15 FSI: fail to set advertising intervals beyond legitimate range 16 of [20 ms, 10,240 ms]. 17 PC: power cycle the bluetooth adapter (controller). 18 SR: suspend and resume the DUT (chromebook) 19 20A test represents a component of a test case which comprises a 21sequence of tests. A test case usually requires a tester (user) 22to perform a sequence of actions and make a sequence of 23observations if the test case is performed manually. 24 25A test consists of an optional action such as "register n 26advertisements" and a number of test criteria such as "verifying 27if min advertising interval is set to an expected value" or 28"verifying if advertising is disabled". 29 30""" 31 32import copy 33import logging 34import time 35 36from autotest_lib.client.common_lib import error 37from autotest_lib.server.cros.bluetooth import bluetooth_adpater_tests 38from autotest_lib.server.cros.multimedia import bluetooth_le_facade_adapter 39 40 41test_case_log = bluetooth_adpater_tests.test_case_log 42 43 44class bluetooth_AdapterLEAdvertising( 45 bluetooth_adpater_tests.BluetoothAdapterTests): 46 """Server side bluetooth adapter advertising Test. 47 48 This class comprises a number of test cases to verify 49 bluetooth low-energy advertising. 50 51 Refer to BluetoothAdapterTests for the implementation of the tests 52 performed in this autotest test. 53 54 Refer to the design doc for more details: 55 "Test Cases for Bluetooth Low-Energy Advertising". 56 57 """ 58 59 SUSPEND_TIME = 10 60 61 @staticmethod 62 def get_instance_ids(advertisements): 63 """Get the list of instace IDs starting at 1. 64 65 @param advertisements: a list of advertisements. 66 67 """ 68 return range(1, len(advertisements) + 1) 69 70 71 def suspend_resume(self, suspend_time=SUSPEND_TIME): 72 """Suspend the DUT for a while and then resume. 73 74 @param suspend_time: the suspend time in seconds. 75 76 """ 77 logging.info('The DUT suspends for %d seconds...', suspend_time) 78 self.host.suspend(suspend_time=suspend_time) 79 logging.info('The DUT is waken up.') 80 81 82 def register_advertisements(self, advertisements, min_adv_interval_ms, 83 max_adv_interval_ms, instance_ids=None): 84 """Register multiple advertisements continuously. 85 86 @param advertisements: a list of advertisement instances. 87 @param min_adv_interval_ms: min_adv_interval in milliseconds. 88 @param max_adv_interval_ms: max_adv_interval in milliseconds. 89 @param instance_ids: the list of instance IDs to register. 90 91 """ 92 if instance_ids is None: 93 instance_ids = self.get_instance_ids(advertisements) 94 95 for instance_id, advertisement in zip(instance_ids, advertisements): 96 self.test_register_advertisement(advertisement, 97 instance_id, 98 min_adv_interval_ms, 99 max_adv_interval_ms) 100 101 102 def unregister_advertisements(self, advertisements, min_adv_interval_ms, 103 max_adv_interval_ms, instance_ids=None): 104 """Register multiple advertisements. 105 106 @param advertisements: a list of advertisement instances. 107 @param min_adv_interval_ms: min_adv_interval in milliseconds. 108 @param max_adv_interval_ms: max_adv_interval in milliseconds. 109 @param instance_ids: the list of instance IDs to unregister. 110 111 """ 112 if instance_ids is None: 113 instance_ids = self.get_instance_ids(advertisements) 114 115 count = 0 116 number_advs = len(advertisements) 117 for instance_id, advertisement in zip(instance_ids, advertisements): 118 # Advertising is only disabled at the removal of the 119 # last advertisement. 120 count += 1 121 advertising_disabled = count == number_advs 122 self.test_unregister_advertisement(advertisement, 123 instance_id, 124 min_adv_interval_ms, 125 max_adv_interval_ms, 126 advertising_disabled) 127 128 129 # --------------------------------------------------------------- 130 # Definitions of all test cases 131 # --------------------------------------------------------------- 132 133 134 @test_case_log 135 def test_case_SI200_RA3_CD_UA3(self): 136 """Test Case: SI(200) - RA(3) - CD - UA(3)""" 137 new_min_adv_interval_ms = 200 138 new_max_adv_interval_ms = 200 139 advertisements = self.three_advertisements 140 141 self.test_reset_advertising() 142 143 self.test_set_advertising_intervals(new_min_adv_interval_ms, 144 new_max_adv_interval_ms) 145 146 self.register_advertisements(advertisements, new_min_adv_interval_ms, 147 new_max_adv_interval_ms) 148 149 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 150 new_max_adv_interval_ms, 151 len(advertisements)) 152 153 self.unregister_advertisements(advertisements, new_min_adv_interval_ms, 154 new_max_adv_interval_ms) 155 156 157 @test_case_log 158 def test_case_SI200_RA3_CD_RA1_CD_UA1_CD_UA3(self): 159 """Test Case: SI(200) - RA(3) - CD - RA(1) - CD - UA(1) - CD - UA(3)""" 160 new_min_adv_interval_ms = 200 161 new_max_adv_interval_ms = 200 162 # Make a copy of advertisements since we are going to modify it. 163 advertisements = copy.copy(self.three_advertisements) 164 number_advs = len(advertisements) 165 one_more_advertisement = [self.sixth_advertisement] 166 167 self.test_reset_advertising() 168 169 self.test_set_advertising_intervals(new_min_adv_interval_ms, 170 new_max_adv_interval_ms) 171 172 self.register_advertisements(advertisements, new_min_adv_interval_ms, 173 new_max_adv_interval_ms) 174 175 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 176 new_max_adv_interval_ms, 177 number_advs) 178 179 # Register one more advertisement. 180 # The instance ID to register is len(advertisements) + 1 = 4 181 self.register_advertisements(one_more_advertisement, 182 new_min_adv_interval_ms, 183 new_max_adv_interval_ms, 184 instance_ids=[number_advs + 1]) 185 186 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 187 new_max_adv_interval_ms, 188 number_advs + 1) 189 190 # Unregister the 3rd advertisement. 191 # After removing the advertisement, the remaining instance IDs 192 # would be [1, 2, 4] 193 instance_id = 3 194 self.test_unregister_advertisement(advertisements.pop(instance_id - 1), 195 instance_id, 196 new_min_adv_interval_ms, 197 new_max_adv_interval_ms, 198 advertising_disabled=False) 199 200 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 201 new_max_adv_interval_ms, 202 number_advs) 203 204 # Unregister all existing advertisements which are [1, 2, 4] 205 # since adv 3 was removed in the previous step. 206 self.unregister_advertisements(advertisements + one_more_advertisement, 207 new_min_adv_interval_ms, 208 new_max_adv_interval_ms, 209 instance_ids=[1, 2, 4]) 210 211 212 @test_case_log 213 def test_case_SI200_RA3_CD_RS(self): 214 """Test Case: SI(200) - RA(3) - CD - RS""" 215 new_min_adv_interval_ms = 200 216 new_max_adv_interval_ms = 200 217 advertisements = self.three_advertisements 218 number_advs = len(advertisements) 219 220 self.test_reset_advertising() 221 222 self.test_set_advertising_intervals(new_min_adv_interval_ms, 223 new_max_adv_interval_ms) 224 225 self.register_advertisements(advertisements, new_min_adv_interval_ms, 226 new_max_adv_interval_ms) 227 228 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 229 new_max_adv_interval_ms, 230 number_advs) 231 232 self.test_reset_advertising(self.get_instance_ids(advertisements)) 233 234 235 @test_case_log 236 def test_case_SI200_RA3_CD_UA1_CD_RS(self): 237 """Test Case: SI(200) - RA(3) - CD - UA(1) - CD - RS""" 238 new_min_adv_interval_ms = 200 239 new_max_adv_interval_ms = 200 240 # Make a copy of advertisements since we are going to modify it. 241 advertisements = copy.copy(self.three_advertisements) 242 243 self.test_reset_advertising() 244 245 self.test_set_advertising_intervals(new_min_adv_interval_ms, 246 new_max_adv_interval_ms) 247 248 self.register_advertisements(advertisements, new_min_adv_interval_ms, 249 new_max_adv_interval_ms) 250 251 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 252 new_max_adv_interval_ms, 253 len(advertisements)) 254 255 # Unregister the 1st advertisement. 256 # After removing the advertisement, the remaining instance IDs 257 # would be [2, 3] 258 instance_id = 1 259 self.test_unregister_advertisement(advertisements.pop(instance_id - 1), 260 instance_id, 261 new_min_adv_interval_ms, 262 new_max_adv_interval_ms, 263 advertising_disabled=False) 264 265 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 266 new_max_adv_interval_ms, 267 len(advertisements) - 1) 268 269 self.test_reset_advertising([2, 3]) 270 271 272 @test_case_log 273 def test_case_SI200_RA3_CD_UA1_CD_RA2_CD_UA4(self): 274 """Test Case: SI(200) - RA(3) - CD - UA(1) - CD - RA(2) - CD - UA(4)""" 275 new_min_adv_interval_ms = 200 276 new_max_adv_interval_ms = 200 277 # Make a copy of three_advertisements since we are going to modify it. 278 advertisements1 = copy.copy(self.three_advertisements) 279 advertisements2 = self.two_advertisements 280 number_advs1 = len(advertisements1) 281 number_advs2 = len(advertisements2) 282 283 self.test_reset_advertising() 284 285 self.test_set_advertising_intervals(new_min_adv_interval_ms, 286 new_max_adv_interval_ms) 287 288 self.register_advertisements(advertisements1, new_min_adv_interval_ms, 289 new_max_adv_interval_ms) 290 291 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 292 new_max_adv_interval_ms, 293 number_advs1) 294 295 # Unregister the 2nd advertisement. 296 # After removing the 2nd advertisement, the remaining instance IDs 297 # would be [1, 3] 298 instance_id = 2 299 self.test_unregister_advertisement(advertisements1.pop(instance_id - 1), 300 instance_id, 301 new_min_adv_interval_ms, 302 new_max_adv_interval_ms, 303 advertising_disabled=False) 304 305 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 306 new_max_adv_interval_ms, 307 number_advs1 - 1) 308 309 # Register two more advertisements. 310 # The instance IDs to register would be [2, 4] 311 self.register_advertisements(advertisements2, new_min_adv_interval_ms, 312 new_max_adv_interval_ms, 313 instance_ids=[2, 4]) 314 315 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 316 new_max_adv_interval_ms, 317 number_advs1 + number_advs2 - 1) 318 319 # Unregister all advertisements. 320 # The instance_ids of advertisements1 is [1, 3]. 321 # The instance_ids of advertisements2 is [2, 4]. 322 self.unregister_advertisements(advertisements1 + advertisements2, 323 new_min_adv_interval_ms, 324 new_max_adv_interval_ms, 325 instance_ids=[1, 3, 2, 4]) 326 327 328 @test_case_log 329 def test_case_SI200_RA5_CD_FRA1_CD_UA5(self): 330 """Test Case: SI(200) - RA(5) - CD - FRA(1) - CD - UA(5)""" 331 new_min_adv_interval_ms = 200 332 new_max_adv_interval_ms = 200 333 advertisements = self.five_advertisements 334 extra_advertisement = self.sixth_advertisement 335 number_advs = len(advertisements) 336 337 self.test_reset_advertising() 338 339 self.test_set_advertising_intervals(new_min_adv_interval_ms, 340 new_max_adv_interval_ms) 341 342 self.register_advertisements(advertisements, new_min_adv_interval_ms, 343 new_max_adv_interval_ms) 344 345 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 346 new_max_adv_interval_ms, 347 number_advs) 348 349 self.test_fail_to_register_advertisement(extra_advertisement, 350 new_min_adv_interval_ms, 351 new_max_adv_interval_ms) 352 353 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 354 new_max_adv_interval_ms, 355 number_advs) 356 357 self.unregister_advertisements(advertisements, new_min_adv_interval_ms, 358 new_max_adv_interval_ms) 359 360 361 @test_case_log 362 def test_case_SI200_RA3_CD_PC_CD_UA3(self): 363 """Test Case: SI(200) - RA(3) - CD - PC - CD - UA(3)""" 364 new_min_adv_interval_ms = 200 365 new_max_adv_interval_ms = 200 366 advertisements = self.three_advertisements 367 368 self.test_reset_advertising() 369 370 self.test_set_advertising_intervals(new_min_adv_interval_ms, 371 new_max_adv_interval_ms) 372 373 self.register_advertisements(advertisements, new_min_adv_interval_ms, 374 new_max_adv_interval_ms) 375 376 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 377 new_max_adv_interval_ms, 378 len(advertisements)) 379 380 # Turn off and then turn on the adapter. 381 self.test_power_off_adapter() 382 time.sleep(1) 383 self.test_power_on_adapter() 384 385 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 386 new_max_adv_interval_ms, 387 len(advertisements)) 388 389 self.unregister_advertisements(advertisements, new_min_adv_interval_ms, 390 new_max_adv_interval_ms) 391 392 393 @test_case_log 394 def test_case_SI200_RA3_CD_SR_CD_UA3(self): 395 """Test Case: SI(200) - RA(3) - CD - SR - CD - UA(3)""" 396 new_min_adv_interval_ms = 200 397 new_max_adv_interval_ms = 200 398 advertisements = self.three_advertisements 399 400 self.test_reset_advertising() 401 402 self.test_set_advertising_intervals(new_min_adv_interval_ms, 403 new_max_adv_interval_ms) 404 405 self.register_advertisements(advertisements, new_min_adv_interval_ms, 406 new_max_adv_interval_ms) 407 408 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 409 new_max_adv_interval_ms, 410 len(advertisements)) 411 412 # Suspend for a while and resume. 413 self.suspend_resume() 414 415 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 416 new_max_adv_interval_ms, 417 len(advertisements)) 418 419 self.unregister_advertisements(advertisements, new_min_adv_interval_ms, 420 new_max_adv_interval_ms) 421 422 423 @test_case_log 424 def test_case_RA3_CD_SI200_CD_UA3(self): 425 """Test Case: RA(3) - CD - SI(200) - CD - UA(3)""" 426 orig_min_adv_interval_ms = self.DAFAULT_MIN_ADVERTISEMENT_INTERVAL_MS 427 orig_max_adv_interval_ms = self.DAFAULT_MIN_ADVERTISEMENT_INTERVAL_MS 428 new_min_adv_interval_ms = 200 429 new_max_adv_interval_ms = 200 430 advertisements = self.three_advertisements 431 number_advs = len(advertisements) 432 433 self.test_reset_advertising() 434 435 self.register_advertisements(advertisements, orig_min_adv_interval_ms, 436 orig_max_adv_interval_ms) 437 438 self.test_check_duration_and_intervals(orig_min_adv_interval_ms, 439 orig_max_adv_interval_ms, 440 number_advs) 441 442 self.test_set_advertising_intervals(new_min_adv_interval_ms, 443 new_max_adv_interval_ms) 444 445 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 446 new_max_adv_interval_ms, 447 number_advs) 448 449 self.unregister_advertisements(advertisements, new_min_adv_interval_ms, 450 new_max_adv_interval_ms) 451 452 453 @test_case_log 454 def test_case_RA3_CD_SI200_CD_RS(self): 455 """Test Case: RA(3) - CD - SI(200) - CD - RS""" 456 orig_min_adv_interval_ms = self.DAFAULT_MIN_ADVERTISEMENT_INTERVAL_MS 457 orig_max_adv_interval_ms = self.DAFAULT_MIN_ADVERTISEMENT_INTERVAL_MS 458 new_min_adv_interval_ms = 200 459 new_max_adv_interval_ms = 200 460 advertisements = self.three_advertisements 461 number_advs = len(advertisements) 462 463 self.test_reset_advertising() 464 465 self.register_advertisements(advertisements, orig_min_adv_interval_ms, 466 orig_max_adv_interval_ms) 467 468 self.test_check_duration_and_intervals(orig_min_adv_interval_ms, 469 orig_max_adv_interval_ms, 470 number_advs) 471 472 self.test_set_advertising_intervals(new_min_adv_interval_ms, 473 new_max_adv_interval_ms) 474 475 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 476 new_max_adv_interval_ms, 477 number_advs) 478 479 self.test_reset_advertising(self.get_instance_ids(advertisements)) 480 481 482 483 @test_case_log 484 def test_case_RA3_CD_SI200_CD_UA1_CD_RS(self): 485 """Test Case: RA(3) - CD - SI(200) - CD - UA(1) - CD - RS""" 486 orig_min_adv_interval_ms = self.DAFAULT_MIN_ADVERTISEMENT_INTERVAL_MS 487 orig_max_adv_interval_ms = self.DAFAULT_MIN_ADVERTISEMENT_INTERVAL_MS 488 new_min_adv_interval_ms = 200 489 new_max_adv_interval_ms = 200 490 advertisements = self.three_advertisements 491 number_advs = len(advertisements) 492 493 self.test_reset_advertising() 494 495 self.register_advertisements(advertisements, orig_min_adv_interval_ms, 496 orig_max_adv_interval_ms) 497 498 self.test_check_duration_and_intervals(orig_min_adv_interval_ms, 499 orig_max_adv_interval_ms, 500 number_advs) 501 502 self.test_set_advertising_intervals(new_min_adv_interval_ms, 503 new_max_adv_interval_ms) 504 505 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 506 new_max_adv_interval_ms, 507 number_advs) 508 509 # Unregister the 2nd advertisement. 510 instance_id = 2 511 self.test_unregister_advertisement(advertisements[instance_id - 1], 512 instance_id, 513 new_min_adv_interval_ms, 514 new_max_adv_interval_ms, 515 advertising_disabled=False) 516 517 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 518 new_max_adv_interval_ms, 519 number_advs - 1) 520 521 # Test if advertising is reset correctly.Only instances [1, 3] are left. 522 self.test_reset_advertising([1, 3]) 523 524 525 @test_case_log 526 def test_case_RA3_CD_SI200_CD_SI2000_CD_UA3(self): 527 """Test Case: RA(3) - CD - SI(200) - CD - SI(2000) - CD - UA(3)""" 528 orig_min_adv_interval_ms = self.DAFAULT_MIN_ADVERTISEMENT_INTERVAL_MS 529 orig_max_adv_interval_ms = self.DAFAULT_MIN_ADVERTISEMENT_INTERVAL_MS 530 new_small_min_adv_interval_ms = 200 531 new_small_max_adv_interval_ms = 200 532 new_large_min_adv_interval_ms = 2000 533 new_large_max_adv_interval_ms = 2000 534 advertisements = self.three_advertisements 535 number_advs = len(advertisements) 536 537 self.test_reset_advertising() 538 539 self.register_advertisements(advertisements, orig_min_adv_interval_ms, 540 orig_max_adv_interval_ms) 541 542 self.test_check_duration_and_intervals(orig_min_adv_interval_ms, 543 orig_max_adv_interval_ms, 544 number_advs) 545 546 self.test_set_advertising_intervals(new_small_min_adv_interval_ms, 547 new_small_max_adv_interval_ms) 548 549 self.test_check_duration_and_intervals(new_small_min_adv_interval_ms, 550 new_small_max_adv_interval_ms, 551 number_advs) 552 553 self.test_set_advertising_intervals(new_large_min_adv_interval_ms, 554 new_large_max_adv_interval_ms) 555 556 self.test_check_duration_and_intervals(new_large_min_adv_interval_ms, 557 new_large_max_adv_interval_ms, 558 number_advs) 559 560 self.unregister_advertisements(advertisements, 561 new_large_min_adv_interval_ms, 562 new_large_max_adv_interval_ms) 563 564 565 @test_case_log 566 def test_case_RA5_CD_SI200_CD_FRA1_CD_UA5(self): 567 """Test Case: RA(5) - CD - SI(200) - CD - FRA(1) - CD - UA(5)""" 568 orig_min_adv_interval_ms = self.DAFAULT_MIN_ADVERTISEMENT_INTERVAL_MS 569 orig_max_adv_interval_ms = self.DAFAULT_MIN_ADVERTISEMENT_INTERVAL_MS 570 new_min_adv_interval_ms = 200 571 new_max_adv_interval_ms = 200 572 advertisements = self.five_advertisements 573 extra_advertisement = self.sixth_advertisement 574 number_advs = len(advertisements) 575 576 self.test_reset_advertising() 577 578 self.register_advertisements(advertisements, orig_min_adv_interval_ms, 579 orig_max_adv_interval_ms) 580 581 self.test_check_duration_and_intervals(orig_min_adv_interval_ms, 582 orig_max_adv_interval_ms, 583 number_advs) 584 585 self.test_set_advertising_intervals(new_min_adv_interval_ms, 586 new_max_adv_interval_ms) 587 588 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 589 new_max_adv_interval_ms, 590 number_advs) 591 592 self.test_fail_to_register_advertisement(extra_advertisement, 593 new_min_adv_interval_ms, 594 new_max_adv_interval_ms) 595 596 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 597 new_max_adv_interval_ms, 598 number_advs) 599 600 self.unregister_advertisements(advertisements, new_min_adv_interval_ms, 601 new_max_adv_interval_ms) 602 603 604 @test_case_log 605 def test_case_RA3_CD_SI200_CD_FSI10_CD_FSI20000_CD_UA3(self): 606 """Test Case: RA(3) - CD - SI(200) - CD - FSI(10) - CD - FSI(20000) - CD 607 - UA(3) 608 """ 609 orig_min_adv_interval_ms = self.DAFAULT_MIN_ADVERTISEMENT_INTERVAL_MS 610 orig_max_adv_interval_ms = self.DAFAULT_MIN_ADVERTISEMENT_INTERVAL_MS 611 new_min_adv_interval_ms = 200 612 new_max_adv_interval_ms = 200 613 invalid_small_min_adv_interval_ms = 10 614 invalid_small_max_adv_interval_ms = 10 615 invalid_large_min_adv_interval_ms = 20000 616 invalid_large_max_adv_interval_ms = 20000 617 advertisements = self.three_advertisements 618 number_advs = len(advertisements) 619 620 self.test_reset_advertising() 621 622 self.register_advertisements(advertisements, orig_min_adv_interval_ms, 623 orig_max_adv_interval_ms) 624 625 self.test_check_duration_and_intervals(orig_min_adv_interval_ms, 626 orig_max_adv_interval_ms, 627 number_advs) 628 629 self.test_set_advertising_intervals(new_min_adv_interval_ms, 630 new_max_adv_interval_ms) 631 632 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 633 new_max_adv_interval_ms, 634 number_advs) 635 636 # Fails to set intervals that are too small. Intervals remain the same. 637 self.test_fail_to_set_advertising_intervals( 638 invalid_small_min_adv_interval_ms, 639 invalid_small_max_adv_interval_ms, 640 new_min_adv_interval_ms, new_max_adv_interval_ms) 641 642 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 643 new_max_adv_interval_ms, 644 number_advs) 645 646 # Fails to set intervals that are too large. Intervals remain the same. 647 self.test_fail_to_set_advertising_intervals( 648 invalid_large_min_adv_interval_ms, 649 invalid_large_max_adv_interval_ms, 650 new_min_adv_interval_ms, new_max_adv_interval_ms) 651 652 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 653 new_max_adv_interval_ms, 654 number_advs) 655 656 # Unregister all advertisements. 657 self.unregister_advertisements(advertisements, new_min_adv_interval_ms, 658 new_max_adv_interval_ms) 659 660 661 @test_case_log 662 def test_case_RA3_CD_SI200_CD_PC_CD_UA3(self): 663 """Test Case: RA(3) - CD - SI(200) - CD - PC - CD - UA(3)""" 664 orig_min_adv_interval_ms = self.DAFAULT_MIN_ADVERTISEMENT_INTERVAL_MS 665 orig_max_adv_interval_ms = self.DAFAULT_MIN_ADVERTISEMENT_INTERVAL_MS 666 new_min_adv_interval_ms = 200 667 new_max_adv_interval_ms = 200 668 advertisements = self.three_advertisements 669 number_advs = len(advertisements) 670 671 self.test_reset_advertising() 672 673 self.register_advertisements(advertisements, orig_min_adv_interval_ms, 674 orig_max_adv_interval_ms) 675 676 self.test_check_duration_and_intervals(orig_min_adv_interval_ms, 677 orig_max_adv_interval_ms, 678 number_advs) 679 680 self.test_set_advertising_intervals(new_min_adv_interval_ms, 681 new_max_adv_interval_ms) 682 683 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 684 new_max_adv_interval_ms, 685 number_advs) 686 687 # Turn off and then turn on the adapter. 688 self.test_power_off_adapter() 689 time.sleep(1) 690 self.test_power_on_adapter() 691 692 # Check if the advertising durations remain the same after resume. 693 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 694 new_max_adv_interval_ms, 695 number_advs) 696 697 # Unregister all advertisements. 698 self.unregister_advertisements(advertisements, new_min_adv_interval_ms, 699 new_max_adv_interval_ms) 700 701 702 @test_case_log 703 def test_case_RA3_CD_SI200_CD_SR_CD_UA3(self): 704 """Test Case: RA(3) - CD - SI(200) - CD - SR - CD - UA(3)""" 705 orig_min_adv_interval_ms = self.DAFAULT_MIN_ADVERTISEMENT_INTERVAL_MS 706 orig_max_adv_interval_ms = self.DAFAULT_MIN_ADVERTISEMENT_INTERVAL_MS 707 new_min_adv_interval_ms = 200 708 new_max_adv_interval_ms = 200 709 advertisements = self.three_advertisements 710 number_advs = len(advertisements) 711 712 self.test_reset_advertising() 713 714 self.register_advertisements(advertisements, orig_min_adv_interval_ms, 715 orig_max_adv_interval_ms) 716 717 self.test_check_duration_and_intervals(orig_min_adv_interval_ms, 718 orig_max_adv_interval_ms, 719 number_advs) 720 721 self.test_set_advertising_intervals(new_min_adv_interval_ms, 722 new_max_adv_interval_ms) 723 724 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 725 new_max_adv_interval_ms, 726 number_advs) 727 728 # Suspend for a while and resume. 729 self.suspend_resume() 730 731 # Check if the advertising durations remain the same after resume. 732 self.test_check_duration_and_intervals(new_min_adv_interval_ms, 733 new_max_adv_interval_ms, 734 number_advs) 735 736 # Unregister all advertisements. 737 self.unregister_advertisements(advertisements, new_min_adv_interval_ms, 738 new_max_adv_interval_ms) 739 740 741 def run_once(self, host, advertisements, multi_advertising): 742 """Running Bluetooth adapter LE advertising autotest. 743 744 @param host: device under test host. 745 @param advertisements: a list of advertisement instances. 746 @param multi_advertising: indicating if this is multi-advertising. 747 748 """ 749 self.host = host 750 self.advertisements = advertisements 751 self.five_advertisements = advertisements[0:5] 752 self.three_advertisements = advertisements[0:3] 753 self.two_advertisements = advertisements[3:5] 754 self.sixth_advertisement = advertisements[5] 755 756 ble_adapter = bluetooth_le_facade_adapter.BluetoothLEFacadeRemoteAdapter 757 self.bluetooth_le_facade = ble_adapter(self.host) 758 self.bluetooth_facade = self.bluetooth_le_facade 759 760 # Reset the adapter to forget previous stored data and turn it on. 761 self.test_reset_on_adapter() 762 763 if multi_advertising: 764 # Run all test cases for multiple advertisements. 765 self.test_case_SI200_RA3_CD_UA3() 766 self.test_case_SI200_RA3_CD_RA1_CD_UA1_CD_UA3() 767 self.test_case_SI200_RA3_CD_RS() 768 self.test_case_SI200_RA3_CD_UA1_CD_RS() 769 self.test_case_SI200_RA3_CD_PC_CD_UA3() 770 self.test_case_SI200_RA3_CD_SR_CD_UA3() 771 self.test_case_SI200_RA3_CD_UA1_CD_RA2_CD_UA4() 772 self.test_case_SI200_RA5_CD_FRA1_CD_UA5() 773 self.test_case_RA3_CD_SI200_CD_UA3() 774 self.test_case_RA3_CD_SI200_CD_RS() 775 self.test_case_RA3_CD_SI200_CD_UA1_CD_RS() 776 self.test_case_RA3_CD_SI200_CD_SI2000_CD_UA3() 777 self.test_case_RA5_CD_SI200_CD_FRA1_CD_UA5() 778 self.test_case_RA3_CD_SI200_CD_FSI10_CD_FSI20000_CD_UA3() 779 self.test_case_RA3_CD_SI200_CD_PC_CD_UA3() 780 self.test_case_RA3_CD_SI200_CD_SR_CD_UA3() 781 782 else: 783 # Run all test cases for single advertisement. 784 # TODO(josephsih): add test cases for single-advertising. 785 786 # Note: it is required to change the advertisement instance 787 # so that the advertisement data could be monitored by btmon. 788 # Otherwise, the advertisement data would be just cached and 789 # reused such that the data would not be visible in btmon. 790 pass 791 792 if self.fails: 793 raise error.TestFail(self.fails) 794