1#!/usr/bin/python3.4 2# 3# Copyright 2017 - The Android Open Source Project 4# 5# Licensed under the Apache License, Version 2.0 (the "License"); 6# you may not use this file except in compliance with the License. 7# You may obtain a copy of 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, 13# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14# See the License for the specific language governing permissions and 15# limitations under the License. 16 17import sys 18import time 19 20from acts import asserts 21from acts.test_decorators import test_tracker_info 22from acts.test_utils.net import connectivity_const as cconsts 23from acts.test_utils.wifi.aware import aware_const as aconsts 24from acts.test_utils.wifi.aware import aware_test_utils as autils 25from acts.test_utils.wifi.aware.AwareBaseTest import AwareBaseTest 26from acts.test_utils.wifi.rtt import rtt_const as rconsts 27from acts.test_utils.wifi.rtt import rtt_test_utils as rutils 28from acts.test_utils.wifi.rtt.RttBaseTest import RttBaseTest 29 30 31class AwareDiscoveryWithRangingTest(AwareBaseTest, RttBaseTest): 32 """Set of tests for Wi-Fi Aware discovery configured with ranging (RTT).""" 33 34 SERVICE_NAME = "GoogleTestServiceRRRRR" 35 36 # Flag indicating whether the device has a limitation that does not allow it 37 # to execute Aware-based Ranging (whether direct or as part of discovery) 38 # whenever NDP is enabled. 39 RANGING_NDP_CONCURRENCY_LIMITATION = True 40 41 # Flag indicating whether the device has a limitation that does not allow it 42 # to execute Aware-based Ranging (whether direct or as part of discovery) 43 # for both Initiators and Responders. Only the first mode works. 44 RANGING_INITIATOR_RESPONDER_CONCURRENCY_LIMITATION = True 45 46 def __init__(self, controllers): 47 AwareBaseTest.__init__(self, controllers) 48 RttBaseTest.__init__(self, controllers) 49 50 def setup_test(self): 51 """Manual setup here due to multiple inheritance: explicitly execute the 52 setup method from both parents.""" 53 AwareBaseTest.setup_test(self) 54 RttBaseTest.setup_test(self) 55 56 def teardown_test(self): 57 """Manual teardown here due to multiple inheritance: explicitly execute the 58 teardown method from both parents.""" 59 AwareBaseTest.teardown_test(self) 60 RttBaseTest.teardown_test(self) 61 62 ######################################################################### 63 64 def run_discovery(self, 65 p_config, 66 s_config, 67 expect_discovery, 68 expect_range=False): 69 """Run discovery on the 2 input devices with the specified configurations. 70 71 Args: 72 p_config, s_config: Publisher and Subscriber discovery configuration. 73 expect_discovery: True or False indicating whether discovery is expected 74 with the specified configurations. 75 expect_range: True if we expect distance results (i.e. ranging to happen). 76 Only relevant if expect_discovery is True. 77 Returns: 78 p_dut, s_dut: Publisher/Subscribe DUT 79 p_disc_id, s_disc_id: Publisher/Subscribe discovery session ID 80 """ 81 p_dut = self.android_devices[0] 82 p_dut.pretty_name = "Publisher" 83 s_dut = self.android_devices[1] 84 s_dut.pretty_name = "Subscriber" 85 86 # Publisher+Subscriber: attach and wait for confirmation 87 p_id = p_dut.droid.wifiAwareAttach(False) 88 autils.wait_for_event(p_dut, aconsts.EVENT_CB_ON_ATTACHED) 89 time.sleep(self.device_startup_offset) 90 s_id = s_dut.droid.wifiAwareAttach(False) 91 autils.wait_for_event(s_dut, aconsts.EVENT_CB_ON_ATTACHED) 92 93 # Publisher: start publish and wait for confirmation 94 p_disc_id = p_dut.droid.wifiAwarePublish(p_id, p_config) 95 autils.wait_for_event(p_dut, aconsts.SESSION_CB_ON_PUBLISH_STARTED) 96 97 # Subscriber: start subscribe and wait for confirmation 98 s_disc_id = s_dut.droid.wifiAwareSubscribe(s_id, s_config) 99 autils.wait_for_event(s_dut, aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED) 100 101 # Subscriber: wait or fail on service discovery 102 if expect_discovery: 103 event = autils.wait_for_event( 104 s_dut, aconsts.SESSION_CB_ON_SERVICE_DISCOVERED) 105 if expect_range: 106 asserts.assert_true( 107 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 108 "Discovery with ranging expected!") 109 else: 110 asserts.assert_false( 111 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 112 "Discovery with ranging NOT expected!") 113 else: 114 autils.fail_on_event(s_dut, 115 aconsts.SESSION_CB_ON_SERVICE_DISCOVERED) 116 117 # (single) sleep for timeout period and then verify that no further events 118 time.sleep(autils.EVENT_TIMEOUT) 119 autils.verify_no_more_events(p_dut, timeout=0) 120 autils.verify_no_more_events(s_dut, timeout=0) 121 122 return p_dut, s_dut, p_disc_id, s_disc_id 123 124 def run_discovery_update(self, 125 p_dut, 126 s_dut, 127 p_disc_id, 128 s_disc_id, 129 p_config, 130 s_config, 131 expect_discovery, 132 expect_range=False): 133 """Run discovery on the 2 input devices with the specified update 134 configurations. I.e. update the existing discovery sessions with the 135 configurations. 136 137 Args: 138 p_dut, s_dut: Publisher/Subscriber DUTs. 139 p_disc_id, s_disc_id: Publisher/Subscriber discovery session IDs. 140 p_config, s_config: Publisher and Subscriber discovery configuration. 141 expect_discovery: True or False indicating whether discovery is expected 142 with the specified configurations. 143 expect_range: True if we expect distance results (i.e. ranging to happen). 144 Only relevant if expect_discovery is True. 145 """ 146 147 # try to perform reconfiguration at same time (and wait once for all 148 # confirmations) 149 if p_config is not None: 150 p_dut.droid.wifiAwareUpdatePublish(p_disc_id, p_config) 151 if s_config is not None: 152 s_dut.droid.wifiAwareUpdateSubscribe(s_disc_id, s_config) 153 154 if p_config is not None: 155 autils.wait_for_event(p_dut, 156 aconsts.SESSION_CB_ON_SESSION_CONFIG_UPDATED) 157 if s_config is not None: 158 autils.wait_for_event(s_dut, 159 aconsts.SESSION_CB_ON_SESSION_CONFIG_UPDATED) 160 161 # Subscriber: wait or fail on service discovery 162 if expect_discovery: 163 event = autils.wait_for_event( 164 s_dut, aconsts.SESSION_CB_ON_SERVICE_DISCOVERED) 165 if expect_range: 166 asserts.assert_true( 167 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 168 "Discovery with ranging expected!") 169 else: 170 asserts.assert_false( 171 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 172 "Discovery with ranging NOT expected!") 173 else: 174 autils.fail_on_event(s_dut, 175 aconsts.SESSION_CB_ON_SERVICE_DISCOVERED) 176 177 # (single) sleep for timeout period and then verify that no further events 178 time.sleep(autils.EVENT_TIMEOUT) 179 autils.verify_no_more_events(p_dut, timeout=0) 180 autils.verify_no_more_events(s_dut, timeout=0) 181 182 def run_discovery_prange_sminmax_outofrange(self, is_unsolicited_passive): 183 """Run discovery with ranging: 184 - Publisher enables ranging 185 - Subscriber enables ranging with min/max such that out of range (min=large, 186 max=large+1) 187 188 Expected: no discovery 189 190 This is a baseline test for the update-configuration tests. 191 192 Args: 193 is_unsolicited_passive: True for Unsolicited/Passive, False for 194 Solicited/Active. 195 Returns: the return arguments of the run_discovery. 196 """ 197 pub_type = (aconsts.PUBLISH_TYPE_UNSOLICITED if is_unsolicited_passive 198 else aconsts.PUBLISH_TYPE_SOLICITED) 199 sub_type = (aconsts.SUBSCRIBE_TYPE_PASSIVE if is_unsolicited_passive 200 else aconsts.SUBSCRIBE_TYPE_ACTIVE) 201 return self.run_discovery( 202 p_config=autils.add_ranging_to_pub( 203 autils.create_discovery_config( 204 self.SERVICE_NAME, pub_type, ssi=self.getname(2)), 205 enable_ranging=True), 206 s_config=autils.add_ranging_to_sub( 207 autils.create_discovery_config( 208 self.SERVICE_NAME, sub_type, ssi=self.getname(2)), 209 min_distance_mm=1000000, 210 max_distance_mm=1000001), 211 expect_discovery=False) 212 213 def getname(self, level=1): 214 """Python magic to return the name of the *calling* function. 215 216 Args: 217 level: How many levels up to go for the method name. Default = calling 218 method. 219 """ 220 return sys._getframe(level).f_code.co_name 221 222 ######################################################################### 223 # Run discovery with ranging configuration. 224 # 225 # Names: test_ranged_discovery_<ptype>_<stype>_<p_range>_<s_range>_<ref_dist> 226 # 227 # where: 228 # <ptype>_<stype>: unsolicited_passive or solicited_active 229 # <p_range>: prange or pnorange 230 # <s_range>: smin or smax or sminmax or snorange 231 # <ref_distance>: inrange or outoforange 232 ######################################################################### 233 234 @test_tracker_info(uuid="3a216e9a-7a57-4741-89c0-84456975e1ac") 235 def test_ranged_discovery_unsolicited_passive_prange_snorange(self): 236 """Verify discovery with ranging: 237 - Unsolicited Publish/Passive Subscribe 238 - Publisher enables ranging 239 - Subscriber disables ranging 240 241 Expect: normal discovery (as if no ranging performed) - no distance 242 """ 243 self.run_discovery( 244 p_config=autils.add_ranging_to_pub( 245 autils.create_discovery_config( 246 self.SERVICE_NAME, 247 aconsts.PUBLISH_TYPE_UNSOLICITED, 248 ssi=self.getname()), 249 enable_ranging=True), 250 s_config=autils.create_discovery_config( 251 self.SERVICE_NAME, 252 aconsts.SUBSCRIBE_TYPE_PASSIVE, 253 ssi=self.getname()), 254 expect_discovery=True, 255 expect_range=False) 256 257 @test_tracker_info(uuid="859a321e-18e2-437b-aa7a-2a45a42ee737") 258 def test_ranged_discovery_solicited_active_prange_snorange(self): 259 """Verify discovery with ranging: 260 - Solicited Publish/Active Subscribe 261 - Publisher enables ranging 262 - Subscriber disables ranging 263 264 Expect: normal discovery (as if no ranging performed) - no distance 265 """ 266 self.run_discovery( 267 p_config=autils.add_ranging_to_pub( 268 autils.create_discovery_config( 269 self.SERVICE_NAME, 270 aconsts.PUBLISH_TYPE_SOLICITED, 271 ssi=self.getname()), 272 enable_ranging=True), 273 s_config=autils.create_discovery_config( 274 self.SERVICE_NAME, 275 aconsts.SUBSCRIBE_TYPE_ACTIVE, 276 ssi=self.getname()), 277 expect_discovery=True, 278 expect_range=False) 279 280 @test_tracker_info(uuid="12a4f899-4f70-4641-8f3c-351004669b71") 281 def test_ranged_discovery_unsolicited_passive_pnorange_smax_inrange(self): 282 """Verify discovery with ranging: 283 - Unsolicited Publish/Passive Subscribe 284 - Publisher disables ranging 285 - Subscriber enables ranging with max such that always within range (large 286 max) 287 288 Expect: normal discovery (as if no ranging performed) - no distance 289 """ 290 self.run_discovery( 291 p_config=autils.add_ranging_to_pub( 292 autils.create_discovery_config( 293 self.SERVICE_NAME, 294 aconsts.PUBLISH_TYPE_UNSOLICITED, 295 ssi=self.getname()), 296 enable_ranging=False), 297 s_config=autils.add_ranging_to_sub( 298 autils.create_discovery_config( 299 self.SERVICE_NAME, 300 aconsts.SUBSCRIBE_TYPE_PASSIVE, 301 ssi=self.getname()), 302 min_distance_mm=None, 303 max_distance_mm=1000000), 304 expect_discovery=True, 305 expect_range=False) 306 307 @test_tracker_info(uuid="b7f90793-113d-4355-be20-856d92ac939f") 308 def test_ranged_discovery_solicited_active_pnorange_smax_inrange(self): 309 """Verify discovery with ranging: 310 - Solicited Publish/Active Subscribe 311 - Publisher disables ranging 312 - Subscriber enables ranging with max such that always within range (large 313 max) 314 315 Expect: normal discovery (as if no ranging performed) - no distance 316 """ 317 self.run_discovery( 318 p_config=autils.add_ranging_to_pub( 319 autils.create_discovery_config( 320 self.SERVICE_NAME, 321 aconsts.PUBLISH_TYPE_SOLICITED, 322 ssi=self.getname()), 323 enable_ranging=False), 324 s_config=autils.add_ranging_to_sub( 325 autils.create_discovery_config( 326 self.SERVICE_NAME, 327 aconsts.SUBSCRIBE_TYPE_ACTIVE, 328 ssi=self.getname()), 329 min_distance_mm=None, 330 max_distance_mm=1000000), 331 expect_discovery=True, 332 expect_range=False) 333 334 @test_tracker_info(uuid="da3ab6df-58f9-44ae-b7be-8200d9e1bb76") 335 def test_ranged_discovery_unsolicited_passive_pnorange_smin_outofrange( 336 self): 337 """Verify discovery with ranging: 338 - Unsolicited Publish/Passive Subscribe 339 - Publisher disables ranging 340 - Subscriber enables ranging with min such that always out of range (large 341 min) 342 343 Expect: normal discovery (as if no ranging performed) - no distance 344 """ 345 self.run_discovery( 346 p_config=autils.add_ranging_to_pub( 347 autils.create_discovery_config( 348 self.SERVICE_NAME, 349 aconsts.PUBLISH_TYPE_UNSOLICITED, 350 ssi=self.getname()), 351 enable_ranging=False), 352 s_config=autils.add_ranging_to_sub( 353 autils.create_discovery_config( 354 self.SERVICE_NAME, 355 aconsts.SUBSCRIBE_TYPE_PASSIVE, 356 ssi=self.getname()), 357 min_distance_mm=1000000, 358 max_distance_mm=None), 359 expect_discovery=True, 360 expect_range=False) 361 362 @test_tracker_info(uuid="275e0806-f266-4fa6-9ca0-1cfd7b65a6ca") 363 def test_ranged_discovery_solicited_active_pnorange_smin_outofrange(self): 364 """Verify discovery with ranging: 365 - Solicited Publish/Active Subscribe 366 - Publisher disables ranging 367 - Subscriber enables ranging with min such that always out of range (large 368 min) 369 370 Expect: normal discovery (as if no ranging performed) - no distance 371 """ 372 self.run_discovery( 373 p_config=autils.add_ranging_to_pub( 374 autils.create_discovery_config( 375 self.SERVICE_NAME, 376 aconsts.PUBLISH_TYPE_SOLICITED, 377 ssi=self.getname()), 378 enable_ranging=False), 379 s_config=autils.add_ranging_to_sub( 380 autils.create_discovery_config( 381 self.SERVICE_NAME, 382 aconsts.SUBSCRIBE_TYPE_ACTIVE, 383 ssi=self.getname()), 384 min_distance_mm=1000000, 385 max_distance_mm=None), 386 expect_discovery=True, 387 expect_range=False) 388 389 @test_tracker_info(uuid="8cd0aa1e-6866-4a5d-a550-f25483eebea1") 390 def test_ranged_discovery_unsolicited_passive_prange_smin_inrange(self): 391 """Verify discovery with ranging: 392 - Unsolicited Publish/Passive Subscribe 393 - Publisher enables ranging 394 - Subscriber enables ranging with min such that in range (min=0) 395 396 Expect: discovery with distance 397 """ 398 self.run_discovery( 399 p_config=autils.add_ranging_to_pub( 400 autils.create_discovery_config( 401 self.SERVICE_NAME, 402 aconsts.PUBLISH_TYPE_UNSOLICITED, 403 ssi=self.getname()), 404 enable_ranging=True), 405 s_config=autils.add_ranging_to_sub( 406 autils.create_discovery_config( 407 self.SERVICE_NAME, 408 aconsts.SUBSCRIBE_TYPE_PASSIVE, 409 ssi=self.getname()), 410 min_distance_mm=0, 411 max_distance_mm=None), 412 expect_discovery=True, 413 expect_range=True) 414 415 @test_tracker_info(uuid="97c22c54-669b-4f7a-bf51-2f484e5f3e74") 416 def test_ranged_discovery_unsolicited_passive_prange_smax_inrange(self): 417 """Verify discovery with ranging: 418 - Unsolicited Publish/Passive Subscribe 419 - Publisher enables ranging 420 - Subscriber enables ranging with max such that in range (max=large) 421 422 Expect: discovery with distance 423 """ 424 self.run_discovery( 425 p_config=autils.add_ranging_to_pub( 426 autils.create_discovery_config( 427 self.SERVICE_NAME, 428 aconsts.PUBLISH_TYPE_UNSOLICITED, 429 ssi=self.getname()), 430 enable_ranging=True), 431 s_config=autils.add_ranging_to_sub( 432 autils.create_discovery_config( 433 self.SERVICE_NAME, 434 aconsts.SUBSCRIBE_TYPE_PASSIVE, 435 ssi=self.getname()), 436 min_distance_mm=None, 437 max_distance_mm=1000000), 438 expect_discovery=True, 439 expect_range=True) 440 441 @test_tracker_info(uuid="616673d7-9d0b-43de-a378-e5e949b51b32") 442 def test_ranged_discovery_unsolicited_passive_prange_sminmax_inrange(self): 443 """Verify discovery with ranging: 444 - Unsolicited Publish/Passive Subscribe 445 - Publisher enables ranging 446 - Subscriber enables ranging with min/max such that in range (min=0, 447 max=large) 448 449 Expect: discovery with distance 450 """ 451 self.run_discovery( 452 p_config=autils.add_ranging_to_pub( 453 autils.create_discovery_config( 454 self.SERVICE_NAME, 455 aconsts.PUBLISH_TYPE_UNSOLICITED, 456 ssi=self.getname()), 457 enable_ranging=True), 458 s_config=autils.add_ranging_to_sub( 459 autils.create_discovery_config( 460 self.SERVICE_NAME, 461 aconsts.SUBSCRIBE_TYPE_PASSIVE, 462 ssi=self.getname()), 463 min_distance_mm=0, 464 max_distance_mm=1000000), 465 expect_discovery=True, 466 expect_range=True) 467 468 @test_tracker_info(uuid="2bf84912-dcad-4a8f-971f-e445a07f05ce") 469 def test_ranged_discovery_solicited_active_prange_smin_inrange(self): 470 """Verify discovery with ranging: 471 - Solicited Publish/Active Subscribe 472 - Publisher enables ranging 473 - Subscriber enables ranging with min such that in range (min=0) 474 475 Expect: discovery with distance 476 """ 477 self.run_discovery( 478 p_config=autils.add_ranging_to_pub( 479 autils.create_discovery_config( 480 self.SERVICE_NAME, 481 aconsts.PUBLISH_TYPE_SOLICITED, 482 ssi=self.getname()), 483 enable_ranging=True), 484 s_config=autils.add_ranging_to_sub( 485 autils.create_discovery_config( 486 self.SERVICE_NAME, 487 aconsts.SUBSCRIBE_TYPE_ACTIVE, 488 ssi=self.getname()), 489 min_distance_mm=0, 490 max_distance_mm=None), 491 expect_discovery=True, 492 expect_range=True) 493 494 @test_tracker_info(uuid="5cfd7961-9665-4742-a1b5-2d1fc97f9795") 495 def test_ranged_discovery_solicited_active_prange_smax_inrange(self): 496 """Verify discovery with ranging: 497 - Solicited Publish/Active Subscribe 498 - Publisher enables ranging 499 - Subscriber enables ranging with max such that in range (max=large) 500 501 Expect: discovery with distance 502 """ 503 self.run_discovery( 504 p_config=autils.add_ranging_to_pub( 505 autils.create_discovery_config( 506 self.SERVICE_NAME, 507 aconsts.PUBLISH_TYPE_SOLICITED, 508 ssi=self.getname()), 509 enable_ranging=True), 510 s_config=autils.add_ranging_to_sub( 511 autils.create_discovery_config( 512 self.SERVICE_NAME, 513 aconsts.SUBSCRIBE_TYPE_ACTIVE, 514 ssi=self.getname()), 515 min_distance_mm=None, 516 max_distance_mm=1000000), 517 expect_discovery=True, 518 expect_range=True) 519 520 @test_tracker_info(uuid="5cf650ad-0b42-4b7d-9e05-d5f45fe0554d") 521 def test_ranged_discovery_solicited_active_prange_sminmax_inrange(self): 522 """Verify discovery with ranging: 523 - Solicited Publish/Active Subscribe 524 - Publisher enables ranging 525 - Subscriber enables ranging with min/max such that in range (min=0, 526 max=large) 527 528 Expect: discovery with distance 529 """ 530 self.run_discovery( 531 p_config=autils.add_ranging_to_pub( 532 autils.create_discovery_config( 533 self.SERVICE_NAME, 534 aconsts.PUBLISH_TYPE_SOLICITED, 535 ssi=self.getname()), 536 enable_ranging=True), 537 s_config=autils.add_ranging_to_sub( 538 autils.create_discovery_config( 539 self.SERVICE_NAME, 540 aconsts.SUBSCRIBE_TYPE_ACTIVE, 541 ssi=self.getname()), 542 min_distance_mm=0, 543 max_distance_mm=1000000), 544 expect_discovery=True, 545 expect_range=True) 546 547 @test_tracker_info(uuid="5277f418-ac35-43ce-9b30-3c895272898e") 548 def test_ranged_discovery_unsolicited_passive_prange_smin_outofrange(self): 549 """Verify discovery with ranging: 550 - Unsolicited Publish/Passive Subscribe 551 - Publisher enables ranging 552 - Subscriber enables ranging with min such that out of range (min=large) 553 554 Expect: no discovery 555 """ 556 self.run_discovery( 557 p_config=autils.add_ranging_to_pub( 558 autils.create_discovery_config( 559 self.SERVICE_NAME, 560 aconsts.PUBLISH_TYPE_UNSOLICITED, 561 ssi=self.getname()), 562 enable_ranging=True), 563 s_config=autils.add_ranging_to_sub( 564 autils.create_discovery_config( 565 self.SERVICE_NAME, 566 aconsts.SUBSCRIBE_TYPE_PASSIVE, 567 ssi=self.getname()), 568 min_distance_mm=1000000, 569 max_distance_mm=None), 570 expect_discovery=False) 571 572 @test_tracker_info(uuid="8a7e6ab1-acf4-41a7-a5fb-8c164d593b5f") 573 def test_ranged_discovery_unsolicited_passive_prange_smax_outofrange(self): 574 """Verify discovery with ranging: 575 - Unsolicited Publish/Passive Subscribe 576 - Publisher enables ranging 577 - Subscriber enables ranging with max such that in range (max=0) 578 579 Expect: no discovery 580 """ 581 self.run_discovery( 582 p_config=autils.add_ranging_to_pub( 583 autils.create_discovery_config( 584 self.SERVICE_NAME, 585 aconsts.PUBLISH_TYPE_UNSOLICITED, 586 ssi=self.getname()), 587 enable_ranging=True), 588 s_config=autils.add_ranging_to_sub( 589 autils.create_discovery_config( 590 self.SERVICE_NAME, 591 aconsts.SUBSCRIBE_TYPE_PASSIVE, 592 ssi=self.getname()), 593 min_distance_mm=None, 594 max_distance_mm=0), 595 expect_discovery=False) 596 597 @test_tracker_info(uuid="b744f5f9-2641-4373-bf86-3752e2f9aace") 598 def test_ranged_discovery_unsolicited_passive_prange_sminmax_outofrange( 599 self): 600 """Verify discovery with ranging: 601 - Unsolicited Publish/Passive Subscribe 602 - Publisher enables ranging 603 - Subscriber enables ranging with min/max such that out of range (min=large, 604 max=large+1) 605 606 Expect: no discovery 607 """ 608 self.run_discovery( 609 p_config=autils.add_ranging_to_pub( 610 autils.create_discovery_config( 611 self.SERVICE_NAME, 612 aconsts.PUBLISH_TYPE_UNSOLICITED, 613 ssi=self.getname()), 614 enable_ranging=True), 615 s_config=autils.add_ranging_to_sub( 616 autils.create_discovery_config( 617 self.SERVICE_NAME, 618 aconsts.SUBSCRIBE_TYPE_PASSIVE, 619 ssi=self.getname()), 620 min_distance_mm=1000000, 621 max_distance_mm=1000001), 622 expect_discovery=False) 623 624 @test_tracker_info(uuid="d2e94199-b2e6-4fa5-a347-24594883c801") 625 def test_ranged_discovery_solicited_active_prange_smin_outofrange(self): 626 """Verify discovery with ranging: 627 - Solicited Publish/Active Subscribe 628 - Publisher enables ranging 629 - Subscriber enables ranging with min such that out of range (min=large) 630 631 Expect: no discovery 632 """ 633 self.run_discovery( 634 p_config=autils.add_ranging_to_pub( 635 autils.create_discovery_config( 636 self.SERVICE_NAME, 637 aconsts.PUBLISH_TYPE_SOLICITED, 638 ssi=self.getname()), 639 enable_ranging=True), 640 s_config=autils.add_ranging_to_sub( 641 autils.create_discovery_config( 642 self.SERVICE_NAME, 643 aconsts.SUBSCRIBE_TYPE_ACTIVE, 644 ssi=self.getname()), 645 min_distance_mm=1000000, 646 max_distance_mm=None), 647 expect_discovery=False) 648 649 @test_tracker_info(uuid="a5619835-496a-4244-a428-f85cba3d4115") 650 def test_ranged_discovery_solicited_active_prange_smax_outofrange(self): 651 """Verify discovery with ranging: 652 - Solicited Publish/Active Subscribe 653 - Publisher enables ranging 654 - Subscriber enables ranging with max such that out of range (max=0) 655 656 Expect: no discovery 657 """ 658 self.run_discovery( 659 p_config=autils.add_ranging_to_pub( 660 autils.create_discovery_config( 661 self.SERVICE_NAME, 662 aconsts.PUBLISH_TYPE_SOLICITED, 663 ssi=self.getname()), 664 enable_ranging=True), 665 s_config=autils.add_ranging_to_sub( 666 autils.create_discovery_config( 667 self.SERVICE_NAME, 668 aconsts.SUBSCRIBE_TYPE_ACTIVE, 669 ssi=self.getname()), 670 min_distance_mm=None, 671 max_distance_mm=0), 672 expect_discovery=False) 673 674 @test_tracker_info(uuid="12ebd91f-a973-410b-8ee1-0bd86024b921") 675 def test_ranged_discovery_solicited_active_prange_sminmax_outofrange(self): 676 """Verify discovery with ranging: 677 - Solicited Publish/Active Subscribe 678 - Publisher enables ranging 679 - Subscriber enables ranging with min/max such that out of range (min=large, 680 max=large+1) 681 682 Expect: no discovery 683 """ 684 self.run_discovery( 685 p_config=autils.add_ranging_to_pub( 686 autils.create_discovery_config( 687 self.SERVICE_NAME, 688 aconsts.PUBLISH_TYPE_SOLICITED, 689 ssi=self.getname()), 690 enable_ranging=True), 691 s_config=autils.add_ranging_to_sub( 692 autils.create_discovery_config( 693 self.SERVICE_NAME, 694 aconsts.SUBSCRIBE_TYPE_ACTIVE, 695 ssi=self.getname()), 696 min_distance_mm=1000000, 697 max_distance_mm=1000001), 698 expect_discovery=False) 699 700 ######################################################################### 701 # Run discovery with ranging configuration & update configurations after 702 # first run. 703 # 704 # Names: test_ranged_updated_discovery_<ptype>_<stype>_<scenario> 705 # 706 # where: 707 # <ptype>_<stype>: unsolicited_passive or solicited_active 708 # <scenario>: test scenario (details in name) 709 ######################################################################### 710 711 @test_tracker_info(uuid="59442180-4a6c-428f-b926-86000e8339b4") 712 def test_ranged_updated_discovery_unsolicited_passive_oor_to_ir(self): 713 """Verify discovery with ranging operation with updated configuration: 714 - Unsolicited Publish/Passive Subscribe 715 - Publisher enables ranging 716 - Subscriber: 717 - Starts: Ranging enabled, min/max such that out of range (min=large, 718 max=large+1) 719 - Reconfigured to: Ranging enabled, min/max such that in range (min=0, 720 max=large) 721 722 Expect: discovery + ranging after update 723 """ 724 (p_dut, s_dut, p_disc_id, 725 s_disc_id) = self.run_discovery_prange_sminmax_outofrange(True) 726 self.run_discovery_update( 727 p_dut, 728 s_dut, 729 p_disc_id, 730 s_disc_id, 731 p_config=None, # no updates 732 s_config=autils.add_ranging_to_sub( 733 autils.create_discovery_config( 734 self.SERVICE_NAME, 735 aconsts.SUBSCRIBE_TYPE_PASSIVE, 736 ssi=self.getname()), 737 min_distance_mm=0, 738 max_distance_mm=1000000), 739 expect_discovery=True, 740 expect_range=True) 741 742 @test_tracker_info(uuid="60188508-104d-42d5-ac3a-3605093c45d7") 743 def test_ranged_updated_discovery_unsolicited_passive_pub_unrange(self): 744 """Verify discovery with ranging operation with updated configuration: 745 - Unsolicited Publish/Passive Subscribe 746 - Publisher enables ranging 747 - Subscriber: Ranging enabled, min/max such that out of range (min=large, 748 max=large+1) 749 - Reconfigured to: Publisher disables ranging 750 751 Expect: discovery w/o ranging after update 752 """ 753 (p_dut, s_dut, p_disc_id, 754 s_disc_id) = self.run_discovery_prange_sminmax_outofrange(True) 755 self.run_discovery_update( 756 p_dut, 757 s_dut, 758 p_disc_id, 759 s_disc_id, 760 p_config=autils.create_discovery_config( 761 self.SERVICE_NAME, 762 aconsts.PUBLISH_TYPE_UNSOLICITED, 763 ssi=self.getname()), 764 s_config=None, # no updates 765 expect_discovery=True, 766 expect_range=False) 767 768 @test_tracker_info(uuid="f96b434e-751d-4eb5-ae01-0c5c3a6fb4a2") 769 def test_ranged_updated_discovery_unsolicited_passive_sub_unrange(self): 770 """Verify discovery with ranging operation with updated configuration: 771 - Unsolicited Publish/Passive Subscribe 772 - Publisher enables ranging 773 - Subscriber: 774 - Starts: Ranging enabled, min/max such that out of range (min=large, 775 max=large+1) 776 - Reconfigured to: Ranging disabled 777 778 Expect: discovery w/o ranging after update 779 """ 780 (p_dut, s_dut, p_disc_id, 781 s_disc_id) = self.run_discovery_prange_sminmax_outofrange(True) 782 self.run_discovery_update( 783 p_dut, 784 s_dut, 785 p_disc_id, 786 s_disc_id, 787 p_config=None, # no updates 788 s_config=autils.create_discovery_config( 789 self.SERVICE_NAME, 790 aconsts.SUBSCRIBE_TYPE_PASSIVE, 791 ssi=self.getname()), 792 expect_discovery=True, 793 expect_range=False) 794 795 @test_tracker_info(uuid="78970de8-9362-4647-931a-3513bcf58e80") 796 def test_ranged_updated_discovery_unsolicited_passive_sub_oor(self): 797 """Verify discovery with ranging operation with updated configuration: 798 - Unsolicited Publish/Passive Subscribe 799 - Publisher enables ranging 800 - Subscriber: 801 - Starts: Ranging enabled, min/max such that out of range (min=large, 802 max=large+1) 803 - Reconfigured to: different out-of-range setting 804 805 Expect: no discovery after update 806 """ 807 (p_dut, s_dut, p_disc_id, 808 s_disc_id) = self.run_discovery_prange_sminmax_outofrange(True) 809 self.run_discovery_update( 810 p_dut, 811 s_dut, 812 p_disc_id, 813 s_disc_id, 814 p_config=None, # no updates 815 s_config=autils.add_ranging_to_sub( 816 autils.create_discovery_config( 817 self.SERVICE_NAME, 818 aconsts.SUBSCRIBE_TYPE_PASSIVE, 819 ssi=self.getname()), 820 min_distance_mm=100000, 821 max_distance_mm=100001), 822 expect_discovery=False) 823 824 @test_tracker_info(uuid="0841ad05-4899-4521-bd24-04a8e2e345ac") 825 def test_ranged_updated_discovery_unsolicited_passive_pub_same(self): 826 """Verify discovery with ranging operation with updated configuration: 827 - Unsolicited Publish/Passive Subscribe 828 - Publisher enables ranging 829 - Subscriber: Ranging enabled, min/max such that out of range (min=large, 830 max=large+1) 831 - Reconfigured to: Publisher with same settings (ranging enabled) 832 833 Expect: no discovery after update 834 """ 835 (p_dut, s_dut, p_disc_id, 836 s_disc_id) = self.run_discovery_prange_sminmax_outofrange(True) 837 self.run_discovery_update( 838 p_dut, 839 s_dut, 840 p_disc_id, 841 s_disc_id, 842 p_config=autils.add_ranging_to_pub( 843 autils.create_discovery_config( 844 self.SERVICE_NAME, 845 aconsts.PUBLISH_TYPE_UNSOLICITED, 846 ssi=self.getname()), 847 enable_ranging=True), 848 s_config=None, # no updates 849 expect_discovery=False) 850 851 @test_tracker_info(uuid="ec6ca57b-f115-4516-813a-4572b930c8d3") 852 def test_ranged_updated_discovery_unsolicited_passive_multi_step(self): 853 """Verify discovery with ranging operation with updated configuration: 854 - Unsolicited Publish/Passive Subscribe 855 - Publisher enables ranging 856 - Subscriber: Ranging enabled, min/max such that out of range (min=large, 857 max=large+1) 858 - Expect: no discovery 859 - Reconfigured to: Ranging enabled, min/max such that in-range (min=0) 860 - Expect: discovery with ranging 861 - Reconfigured to: Ranging enabled, min/max such that out-of-range 862 (min=large) 863 - Expect: no discovery 864 - Reconfigured to: Ranging disabled 865 - Expect: discovery without ranging 866 """ 867 (p_dut, s_dut, p_disc_id, 868 s_disc_id) = self.run_discovery_prange_sminmax_outofrange(True) 869 self.run_discovery_update( 870 p_dut, 871 s_dut, 872 p_disc_id, 873 s_disc_id, 874 p_config=None, # no updates 875 s_config=autils.add_ranging_to_sub( 876 autils.create_discovery_config( 877 self.SERVICE_NAME, 878 aconsts.SUBSCRIBE_TYPE_PASSIVE, 879 ssi=self.getname()), 880 min_distance_mm=0, 881 max_distance_mm=None), 882 expect_discovery=True, 883 expect_range=True) 884 self.run_discovery_update( 885 p_dut, 886 s_dut, 887 p_disc_id, 888 s_disc_id, 889 p_config=None, # no updates 890 s_config=autils.add_ranging_to_sub( 891 autils.create_discovery_config( 892 self.SERVICE_NAME, 893 aconsts.SUBSCRIBE_TYPE_PASSIVE, 894 ssi=self.getname()), 895 min_distance_mm=1000000, 896 max_distance_mm=None), 897 expect_discovery=False) 898 self.run_discovery_update( 899 p_dut, 900 s_dut, 901 p_disc_id, 902 s_disc_id, 903 p_config=None, # no updates 904 s_config=autils.create_discovery_config( 905 self.SERVICE_NAME, 906 aconsts.SUBSCRIBE_TYPE_PASSIVE, 907 ssi=self.getname()), 908 expect_discovery=True, 909 expect_range=False) 910 911 @test_tracker_info(uuid="bbaac63b-000c-415f-bf19-0906f04031cd") 912 def test_ranged_updated_discovery_solicited_active_oor_to_ir(self): 913 """Verify discovery with ranging operation with updated configuration: 914 - Solicited Publish/Active Subscribe 915 - Publisher enables ranging 916 - Subscriber: 917 - Starts: Ranging enabled, min/max such that out of range (min=large, 918 max=large+1) 919 - Reconfigured to: Ranging enabled, min/max such that in range (min=0, 920 max=large) 921 922 Expect: discovery + ranging after update 923 """ 924 (p_dut, s_dut, p_disc_id, 925 s_disc_id) = self.run_discovery_prange_sminmax_outofrange(False) 926 self.run_discovery_update( 927 p_dut, 928 s_dut, 929 p_disc_id, 930 s_disc_id, 931 p_config=None, # no updates 932 s_config=autils.add_ranging_to_sub( 933 autils.create_discovery_config( 934 self.SERVICE_NAME, 935 aconsts.SUBSCRIBE_TYPE_ACTIVE, 936 ssi=self.getname()), 937 min_distance_mm=0, 938 max_distance_mm=1000000), 939 expect_discovery=True, 940 expect_range=True) 941 942 @test_tracker_info(uuid="c385b361-7955-4f34-9109-8d8ca81cb4cc") 943 def test_ranged_updated_discovery_solicited_active_pub_unrange(self): 944 """Verify discovery with ranging operation with updated configuration: 945 - Solicited Publish/Active Subscribe 946 - Publisher enables ranging 947 - Subscriber: Ranging enabled, min/max such that out of range (min=large, 948 max=large+1) 949 - Reconfigured to: Publisher disables ranging 950 951 Expect: discovery w/o ranging after update 952 """ 953 (p_dut, s_dut, p_disc_id, 954 s_disc_id) = self.run_discovery_prange_sminmax_outofrange(False) 955 self.run_discovery_update( 956 p_dut, 957 s_dut, 958 p_disc_id, 959 s_disc_id, 960 p_config=autils.create_discovery_config( 961 self.SERVICE_NAME, 962 aconsts.PUBLISH_TYPE_SOLICITED, 963 ssi=self.getname()), 964 s_config=None, # no updates 965 expect_discovery=True, 966 expect_range=False) 967 968 @test_tracker_info(uuid="ec5120ea-77ec-48c6-8820-48b82ad3dfd4") 969 def test_ranged_updated_discovery_solicited_active_sub_unrange(self): 970 """Verify discovery with ranging operation with updated configuration: 971 - Solicited Publish/Active Subscribe 972 - Publisher enables ranging 973 - Subscriber: 974 - Starts: Ranging enabled, min/max such that out of range (min=large, 975 max=large+1) 976 - Reconfigured to: Ranging disabled 977 978 Expect: discovery w/o ranging after update 979 """ 980 (p_dut, s_dut, p_disc_id, 981 s_disc_id) = self.run_discovery_prange_sminmax_outofrange(False) 982 self.run_discovery_update( 983 p_dut, 984 s_dut, 985 p_disc_id, 986 s_disc_id, 987 p_config=None, # no updates 988 s_config=autils.create_discovery_config( 989 self.SERVICE_NAME, 990 aconsts.SUBSCRIBE_TYPE_ACTIVE, 991 ssi=self.getname()), 992 expect_discovery=True, 993 expect_range=False) 994 995 @test_tracker_info(uuid="6231cb42-91e4-48d3-b9db-b37efbe8537c") 996 def test_ranged_updated_discovery_solicited_active_sub_oor(self): 997 """Verify discovery with ranging operation with updated configuration: 998 - Solicited Publish/Active Subscribe 999 - Publisher enables ranging 1000 - Subscriber: 1001 - Starts: Ranging enabled, min/max such that out of range (min=large, 1002 max=large+1) 1003 - Reconfigured to: different out-of-range setting 1004 1005 Expect: no discovery after update 1006 """ 1007 (p_dut, s_dut, p_disc_id, 1008 s_disc_id) = self.run_discovery_prange_sminmax_outofrange(False) 1009 self.run_discovery_update( 1010 p_dut, 1011 s_dut, 1012 p_disc_id, 1013 s_disc_id, 1014 p_config=None, # no updates 1015 s_config=autils.add_ranging_to_sub( 1016 autils.create_discovery_config( 1017 self.SERVICE_NAME, 1018 aconsts.SUBSCRIBE_TYPE_ACTIVE, 1019 ssi=self.getname()), 1020 min_distance_mm=100000, 1021 max_distance_mm=100001), 1022 expect_discovery=False) 1023 1024 @test_tracker_info(uuid="ec999420-6a50-455e-b624-f4c9b4cb7ea5") 1025 def test_ranged_updated_discovery_solicited_active_pub_same(self): 1026 """Verify discovery with ranging operation with updated configuration: 1027 - Solicited Publish/Active Subscribe 1028 - Publisher enables ranging 1029 - Subscriber: Ranging enabled, min/max such that out of range (min=large, 1030 max=large+1) 1031 - Reconfigured to: Publisher with same settings (ranging enabled) 1032 1033 Expect: no discovery after update 1034 """ 1035 (p_dut, s_dut, p_disc_id, 1036 s_disc_id) = self.run_discovery_prange_sminmax_outofrange(False) 1037 self.run_discovery_update( 1038 p_dut, 1039 s_dut, 1040 p_disc_id, 1041 s_disc_id, 1042 p_config=autils.add_ranging_to_pub( 1043 autils.create_discovery_config( 1044 self.SERVICE_NAME, 1045 aconsts.PUBLISH_TYPE_SOLICITED, 1046 ssi=self.getname()), 1047 enable_ranging=True), 1048 s_config=None, # no updates 1049 expect_discovery=False) 1050 1051 @test_tracker_info(uuid="ec6ca57b-f115-4516-813a-4572b930c8d3") 1052 def test_ranged_updated_discovery_solicited_active_multi_step(self): 1053 """Verify discovery with ranging operation with updated configuration: 1054 - Unsolicited Publish/Passive Subscribe 1055 - Publisher enables ranging 1056 - Subscriber: Ranging enabled, min/max such that out of range (min=large, 1057 max=large+1) 1058 - Expect: no discovery 1059 - Reconfigured to: Ranging enabled, min/max such that in-range (min=0) 1060 - Expect: discovery with ranging 1061 - Reconfigured to: Ranging enabled, min/max such that out-of-range 1062 (min=large) 1063 - Expect: no discovery 1064 - Reconfigured to: Ranging disabled 1065 - Expect: discovery without ranging 1066 """ 1067 (p_dut, s_dut, p_disc_id, 1068 s_disc_id) = self.run_discovery_prange_sminmax_outofrange(True) 1069 self.run_discovery_update( 1070 p_dut, 1071 s_dut, 1072 p_disc_id, 1073 s_disc_id, 1074 p_config=None, # no updates 1075 s_config=autils.add_ranging_to_sub( 1076 autils.create_discovery_config( 1077 self.SERVICE_NAME, 1078 aconsts.SUBSCRIBE_TYPE_ACTIVE, 1079 ssi=self.getname()), 1080 min_distance_mm=0, 1081 max_distance_mm=None), 1082 expect_discovery=True, 1083 expect_range=True) 1084 self.run_discovery_update( 1085 p_dut, 1086 s_dut, 1087 p_disc_id, 1088 s_disc_id, 1089 p_config=None, # no updates 1090 s_config=autils.add_ranging_to_sub( 1091 autils.create_discovery_config( 1092 self.SERVICE_NAME, 1093 aconsts.SUBSCRIBE_TYPE_ACTIVE, 1094 ssi=self.getname()), 1095 min_distance_mm=1000000, 1096 max_distance_mm=None), 1097 expect_discovery=False) 1098 self.run_discovery_update( 1099 p_dut, 1100 s_dut, 1101 p_disc_id, 1102 s_disc_id, 1103 p_config=None, # no updates 1104 s_config=autils.create_discovery_config( 1105 self.SERVICE_NAME, 1106 aconsts.SUBSCRIBE_TYPE_ACTIVE, 1107 ssi=self.getname()), 1108 expect_discovery=True, 1109 expect_range=False) 1110 1111 ######################################################################### 1112 1113 @test_tracker_info(uuid="6edc47ab-7300-4bff-b7dd-5de83f58928a") 1114 def test_ranged_discovery_multi_session(self): 1115 """Verify behavior with multiple concurrent discovery session with different 1116 configurations: 1117 1118 Device A (Publisher): 1119 Publisher AA: ranging enabled 1120 Publisher BB: ranging enabled 1121 Publisher CC: ranging enabled 1122 Publisher DD: ranging disabled 1123 Device B (Subscriber): 1124 Subscriber AA: ranging out-of-range -> no match 1125 Subscriber BB: ranging in-range -> match w/range 1126 Subscriber CC: ranging disabled -> match w/o range 1127 Subscriber DD: ranging out-of-range -> match w/o range 1128 """ 1129 p_dut = self.android_devices[0] 1130 p_dut.pretty_name = "Publisher" 1131 s_dut = self.android_devices[1] 1132 s_dut.pretty_name = "Subscriber" 1133 1134 # Publisher+Subscriber: attach and wait for confirmation 1135 p_id = p_dut.droid.wifiAwareAttach(False) 1136 autils.wait_for_event(p_dut, aconsts.EVENT_CB_ON_ATTACHED) 1137 time.sleep(self.device_startup_offset) 1138 s_id = s_dut.droid.wifiAwareAttach(False) 1139 autils.wait_for_event(s_dut, aconsts.EVENT_CB_ON_ATTACHED) 1140 1141 # Subscriber: start sessions 1142 aa_s_disc_id = s_dut.droid.wifiAwareSubscribe( 1143 s_id, 1144 autils.add_ranging_to_sub( 1145 autils.create_discovery_config("AA", 1146 aconsts.SUBSCRIBE_TYPE_PASSIVE), 1147 min_distance_mm=1000000, 1148 max_distance_mm=1000001), True) 1149 bb_s_disc_id = s_dut.droid.wifiAwareSubscribe( 1150 s_id, 1151 autils.add_ranging_to_sub( 1152 autils.create_discovery_config("BB", 1153 aconsts.SUBSCRIBE_TYPE_PASSIVE), 1154 min_distance_mm=0, 1155 max_distance_mm=1000000), True) 1156 cc_s_disc_id = s_dut.droid.wifiAwareSubscribe( 1157 s_id, 1158 autils.create_discovery_config( 1159 "CC", aconsts.SUBSCRIBE_TYPE_PASSIVE), True) 1160 dd_s_disc_id = s_dut.droid.wifiAwareSubscribe( 1161 s_id, 1162 autils.add_ranging_to_sub( 1163 autils.create_discovery_config("DD", 1164 aconsts.SUBSCRIBE_TYPE_PASSIVE), 1165 min_distance_mm=1000000, 1166 max_distance_mm=1000001), True) 1167 1168 autils.wait_for_event( 1169 s_dut, 1170 autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED, 1171 aa_s_disc_id)) 1172 autils.wait_for_event( 1173 s_dut, 1174 autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED, 1175 bb_s_disc_id)) 1176 autils.wait_for_event( 1177 s_dut, 1178 autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED, 1179 cc_s_disc_id)) 1180 autils.wait_for_event( 1181 s_dut, 1182 autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED, 1183 dd_s_disc_id)) 1184 1185 # Publisher: start sessions 1186 aa_p_disc_id = p_dut.droid.wifiAwarePublish( 1187 p_id, 1188 autils.add_ranging_to_pub( 1189 autils.create_discovery_config( 1190 "AA", aconsts.PUBLISH_TYPE_UNSOLICITED), 1191 enable_ranging=True), True) 1192 bb_p_disc_id = p_dut.droid.wifiAwarePublish( 1193 p_id, 1194 autils.add_ranging_to_pub( 1195 autils.create_discovery_config( 1196 "BB", aconsts.PUBLISH_TYPE_UNSOLICITED), 1197 enable_ranging=True), True) 1198 cc_p_disc_id = p_dut.droid.wifiAwarePublish( 1199 p_id, 1200 autils.add_ranging_to_pub( 1201 autils.create_discovery_config( 1202 "CC", aconsts.PUBLISH_TYPE_UNSOLICITED), 1203 enable_ranging=True), True) 1204 dd_p_disc_id = p_dut.droid.wifiAwarePublish( 1205 p_id, 1206 autils.create_discovery_config( 1207 "DD", aconsts.PUBLISH_TYPE_UNSOLICITED), True) 1208 1209 autils.wait_for_event( 1210 p_dut, 1211 autils.decorate_event(aconsts.SESSION_CB_ON_PUBLISH_STARTED, 1212 aa_p_disc_id)) 1213 autils.wait_for_event( 1214 p_dut, 1215 autils.decorate_event(aconsts.SESSION_CB_ON_PUBLISH_STARTED, 1216 bb_p_disc_id)) 1217 autils.wait_for_event( 1218 p_dut, 1219 autils.decorate_event(aconsts.SESSION_CB_ON_PUBLISH_STARTED, 1220 cc_p_disc_id)) 1221 autils.wait_for_event( 1222 p_dut, 1223 autils.decorate_event(aconsts.SESSION_CB_ON_PUBLISH_STARTED, 1224 dd_p_disc_id)) 1225 1226 # Expected and unexpected service discovery 1227 event = autils.wait_for_event( 1228 s_dut, 1229 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1230 bb_s_disc_id)) 1231 asserts.assert_true( 1232 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 1233 "Discovery with ranging for BB expected!") 1234 event = autils.wait_for_event( 1235 s_dut, 1236 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1237 cc_s_disc_id)) 1238 asserts.assert_false( 1239 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 1240 "Discovery with ranging for CC NOT expected!") 1241 event = autils.wait_for_event( 1242 s_dut, 1243 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1244 dd_s_disc_id)) 1245 asserts.assert_false( 1246 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 1247 "Discovery with ranging for DD NOT expected!") 1248 autils.fail_on_event( 1249 s_dut, 1250 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1251 aa_s_disc_id)) 1252 1253 # (single) sleep for timeout period and then verify that no further events 1254 time.sleep(autils.EVENT_TIMEOUT) 1255 autils.verify_no_more_events(p_dut, timeout=0) 1256 autils.verify_no_more_events(s_dut, timeout=0) 1257 1258 ######################################################################### 1259 1260 @test_tracker_info(uuid="deede47f-a54c-46d9-88bb-f4482fbd8470") 1261 def test_ndp_concurrency(self): 1262 """Verify the behavior of Wi-Fi Aware Ranging whenever an NDP is created - 1263 for those devices that have a concurrency limitation that does not allow 1264 Aware Ranging, whether direct or as part of discovery. 1265 1266 Publisher: start 3 services 1267 AA w/o ranging 1268 BB w/ ranging 1269 CC w/ ranging 1270 DD w/ ranging 1271 Subscriber: start 2 services 1272 AA w/o ranging 1273 BB w/ ranging out-of-range 1274 (do not start CC!) 1275 DD w/ ranging in-range 1276 Expect AA discovery, DD discovery w/range, but no BB 1277 Start NDP in context of AA 1278 IF NDP_CONCURRENCY_LIMITATION: 1279 Verify discovery on BB w/o range 1280 Start EE w/ranging out-of-range 1281 Start FF w/ranging in-range 1282 IF NDP_CONCURRENCY_LIMITATION: 1283 Verify discovery on EE w/o range 1284 Verify discovery on FF w/o range 1285 Else: 1286 Verify discovery on FF w/ range 1287 Tear down NDP 1288 Subscriber 1289 Start CC w/ ranging out-of-range 1290 Wait to verify that do not get match 1291 Update configuration to be in-range 1292 Verify that get match with ranging information 1293 """ 1294 p_dut = self.android_devices[0] 1295 p_dut.pretty_name = "Publisher" 1296 s_dut = self.android_devices[1] 1297 s_dut.pretty_name = "Subscriber" 1298 1299 # Publisher+Subscriber: attach and wait for confirmation 1300 p_id = p_dut.droid.wifiAwareAttach(False) 1301 autils.wait_for_event(p_dut, aconsts.EVENT_CB_ON_ATTACHED) 1302 time.sleep(self.device_startup_offset) 1303 s_id = s_dut.droid.wifiAwareAttach(False) 1304 autils.wait_for_event(s_dut, aconsts.EVENT_CB_ON_ATTACHED) 1305 1306 # Publisher: AA w/o ranging, BB w/ ranging, CC w/ ranging, DD w/ ranging 1307 aa_p_id = p_dut.droid.wifiAwarePublish( 1308 p_id, 1309 autils.create_discovery_config( 1310 "AA", aconsts.PUBLISH_TYPE_SOLICITED), True) 1311 autils.wait_for_event( 1312 p_dut, 1313 autils.decorate_event(aconsts.SESSION_CB_ON_PUBLISH_STARTED, 1314 aa_p_id)) 1315 bb_p_id = p_dut.droid.wifiAwarePublish( 1316 p_id, 1317 autils.add_ranging_to_pub( 1318 autils.create_discovery_config( 1319 "BB", aconsts.PUBLISH_TYPE_UNSOLICITED), 1320 enable_ranging=True), True) 1321 autils.wait_for_event( 1322 p_dut, 1323 autils.decorate_event(aconsts.SESSION_CB_ON_PUBLISH_STARTED, 1324 bb_p_id)) 1325 cc_p_id = p_dut.droid.wifiAwarePublish( 1326 p_id, 1327 autils.add_ranging_to_pub( 1328 autils.create_discovery_config( 1329 "CC", aconsts.PUBLISH_TYPE_UNSOLICITED), 1330 enable_ranging=True), True) 1331 autils.wait_for_event( 1332 p_dut, 1333 autils.decorate_event(aconsts.SESSION_CB_ON_PUBLISH_STARTED, 1334 cc_p_id)) 1335 dd_p_id = p_dut.droid.wifiAwarePublish( 1336 p_id, 1337 autils.add_ranging_to_pub( 1338 autils.create_discovery_config( 1339 "DD", aconsts.PUBLISH_TYPE_UNSOLICITED), 1340 enable_ranging=True), True) 1341 autils.wait_for_event( 1342 p_dut, 1343 autils.decorate_event(aconsts.SESSION_CB_ON_PUBLISH_STARTED, 1344 dd_p_id)) 1345 1346 # Subscriber: AA w/o ranging, BB w/ranging out-of-range, 1347 # DD w /ranging in-range 1348 aa_s_id = s_dut.droid.wifiAwareSubscribe( 1349 s_id, 1350 autils.create_discovery_config( 1351 "AA", aconsts.SUBSCRIBE_TYPE_ACTIVE), True) 1352 autils.wait_for_event( 1353 s_dut, 1354 autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED, 1355 aa_s_id)) 1356 bb_s_id = s_dut.droid.wifiAwareSubscribe( 1357 s_id, 1358 autils.add_ranging_to_sub( 1359 autils.create_discovery_config("BB", 1360 aconsts.SUBSCRIBE_TYPE_PASSIVE), 1361 min_distance_mm=1000000, 1362 max_distance_mm=1000001), True) 1363 autils.wait_for_event( 1364 s_dut, 1365 autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED, 1366 bb_s_id)) 1367 dd_s_id = s_dut.droid.wifiAwareSubscribe( 1368 s_id, 1369 autils.add_ranging_to_sub( 1370 autils.create_discovery_config("DD", 1371 aconsts.SUBSCRIBE_TYPE_PASSIVE), 1372 min_distance_mm=None, 1373 max_distance_mm=1000000), True) 1374 autils.wait_for_event( 1375 s_dut, 1376 autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED, 1377 dd_s_id)) 1378 1379 # verify: AA discovered, BB not discovered, DD discovery w/range 1380 event = autils.wait_for_event( 1381 s_dut, 1382 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1383 aa_s_id)) 1384 asserts.assert_false( 1385 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 1386 "Discovery with ranging for AA NOT expected!") 1387 aa_peer_id_on_sub = event['data'][aconsts.SESSION_CB_KEY_PEER_ID] 1388 autils.fail_on_event( 1389 s_dut, 1390 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1391 bb_s_id)) 1392 event = autils.wait_for_event( 1393 s_dut, 1394 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1395 dd_s_id)) 1396 asserts.assert_true( 1397 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 1398 "Discovery with ranging for DD expected!") 1399 1400 # start NDP in context of AA: 1401 1402 # Publisher: request network (from ANY) 1403 p_req_key = autils.request_network( 1404 p_dut, p_dut.droid.wifiAwareCreateNetworkSpecifier(aa_p_id, None)) 1405 1406 # Subscriber: request network 1407 s_req_key = autils.request_network( 1408 s_dut, 1409 s_dut.droid.wifiAwareCreateNetworkSpecifier( 1410 aa_s_id, aa_peer_id_on_sub)) 1411 1412 # Publisher & Subscriber: wait for network formation 1413 p_net_event = autils.wait_for_event_with_keys( 1414 p_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_TIMEOUT, 1415 (cconsts.NETWORK_CB_KEY_EVENT, 1416 cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED), 1417 (cconsts.NETWORK_CB_KEY_ID, p_req_key)) 1418 s_net_event = autils.wait_for_event_with_keys( 1419 s_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_TIMEOUT, 1420 (cconsts.NETWORK_CB_KEY_EVENT, 1421 cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED), 1422 (cconsts.NETWORK_CB_KEY_ID, s_req_key)) 1423 1424 p_aware_if = p_net_event["data"][cconsts.NETWORK_CB_KEY_INTERFACE_NAME] 1425 s_aware_if = s_net_event["data"][cconsts.NETWORK_CB_KEY_INTERFACE_NAME] 1426 1427 p_ipv6 = p_dut.droid.connectivityGetLinkLocalIpv6Address( 1428 p_aware_if).split("%")[0] 1429 s_ipv6 = s_dut.droid.connectivityGetLinkLocalIpv6Address( 1430 s_aware_if).split("%")[0] 1431 1432 self.log.info("AA NDP Interface names: P=%s, S=%s", p_aware_if, 1433 s_aware_if) 1434 self.log.info("AA NDP Interface addresses (IPv6): P=%s, S=%s", p_ipv6, 1435 s_ipv6) 1436 1437 if self.RANGING_NDP_CONCURRENCY_LIMITATION: 1438 # Expect BB to now discover w/o ranging 1439 event = autils.wait_for_event( 1440 s_dut, 1441 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1442 bb_s_id)) 1443 asserts.assert_false( 1444 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 1445 "Discovery with ranging for BB NOT expected!") 1446 1447 # Publishers: EE, FF w/ ranging 1448 ee_p_id = p_dut.droid.wifiAwarePublish( 1449 p_id, 1450 autils.add_ranging_to_pub( 1451 autils.create_discovery_config("EE", 1452 aconsts.PUBLISH_TYPE_SOLICITED), 1453 enable_ranging=True), True) 1454 autils.wait_for_event( 1455 p_dut, 1456 autils.decorate_event(aconsts.SESSION_CB_ON_PUBLISH_STARTED, 1457 ee_p_id)) 1458 ff_p_id = p_dut.droid.wifiAwarePublish( 1459 p_id, 1460 autils.add_ranging_to_pub( 1461 autils.create_discovery_config( 1462 "FF", aconsts.PUBLISH_TYPE_UNSOLICITED), 1463 enable_ranging=True), True) 1464 autils.wait_for_event( 1465 p_dut, 1466 autils.decorate_event(aconsts.SESSION_CB_ON_PUBLISH_STARTED, 1467 ff_p_id)) 1468 1469 # Subscribers: EE out-of-range, FF in-range 1470 ee_s_id = s_dut.droid.wifiAwareSubscribe( 1471 s_id, 1472 autils.add_ranging_to_sub( 1473 autils.create_discovery_config("EE", 1474 aconsts.SUBSCRIBE_TYPE_ACTIVE), 1475 min_distance_mm=1000000, 1476 max_distance_mm=1000001), True) 1477 autils.wait_for_event( 1478 s_dut, 1479 autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED, 1480 ee_s_id)) 1481 ff_s_id = s_dut.droid.wifiAwareSubscribe( 1482 s_id, 1483 autils.add_ranging_to_sub( 1484 autils.create_discovery_config("FF", 1485 aconsts.SUBSCRIBE_TYPE_PASSIVE), 1486 min_distance_mm=None, 1487 max_distance_mm=1000000), True) 1488 autils.wait_for_event( 1489 s_dut, 1490 autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED, 1491 ff_s_id)) 1492 1493 if self.RANGING_NDP_CONCURRENCY_LIMITATION: 1494 # Expect EE & FF discovery w/o range 1495 event = autils.wait_for_event( 1496 s_dut, 1497 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1498 ee_s_id)) 1499 asserts.assert_false( 1500 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 1501 "Discovery with ranging for EE NOT expected!") 1502 event = autils.wait_for_event( 1503 s_dut, 1504 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1505 ff_s_id)) 1506 asserts.assert_false( 1507 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 1508 "Discovery with ranging for FF NOT expected!") 1509 else: 1510 event = autils.wait_for_event( 1511 s_dut, 1512 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1513 ff_s_id)) 1514 asserts.assert_true( 1515 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 1516 "Discovery with ranging for FF expected!") 1517 1518 # tear down NDP 1519 p_dut.droid.connectivityUnregisterNetworkCallback(p_req_key) 1520 s_dut.droid.connectivityUnregisterNetworkCallback(s_req_key) 1521 1522 time.sleep(5) # give time for NDP termination to finish 1523 1524 # Subscriber: start CC out-of-range - no discovery expected! 1525 cc_s_id = s_dut.droid.wifiAwareSubscribe( 1526 s_id, 1527 autils.add_ranging_to_sub( 1528 autils.create_discovery_config("CC", 1529 aconsts.SUBSCRIBE_TYPE_PASSIVE), 1530 min_distance_mm=1000000, 1531 max_distance_mm=1000001), True) 1532 autils.wait_for_event( 1533 s_dut, 1534 autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED, 1535 cc_s_id)) 1536 autils.fail_on_event( 1537 s_dut, 1538 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1539 cc_s_id)) 1540 1541 # Subscriber: modify CC to in-range - expect discovery w/ range 1542 s_dut.droid.wifiAwareUpdateSubscribe( 1543 cc_s_id, 1544 autils.add_ranging_to_sub( 1545 autils.create_discovery_config("CC", 1546 aconsts.SUBSCRIBE_TYPE_PASSIVE), 1547 min_distance_mm=None, 1548 max_distance_mm=1000001)) 1549 autils.wait_for_event( 1550 s_dut, 1551 autils.decorate_event(aconsts.SESSION_CB_ON_SESSION_CONFIG_UPDATED, 1552 cc_s_id)) 1553 event = autils.wait_for_event( 1554 s_dut, 1555 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1556 cc_s_id)) 1557 asserts.assert_true( 1558 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 1559 "Discovery with ranging for CC expected!") 1560 1561 @test_tracker_info(uuid="d94dac91-4090-4c03-a867-6dfac6558ba3") 1562 def test_role_concurrency(self): 1563 """Verify the behavior of Wi-Fi Aware Ranging (in the context of discovery) 1564 when the device has concurrency limitations which do not permit concurrent 1565 Initiator and Responder roles on the same device. In such case it is 1566 expected that normal discovery without ranging is executed AND that ranging 1567 is restored whenever the concurrency constraints are removed. 1568 1569 Note: all Subscribers are in-range. 1570 1571 DUT1: start multiple services 1572 Publish AA w/ ranging (unsolicited) 1573 Subscribe BB w/ ranging (active) 1574 Publish CC w/ ranging (unsolicited) 1575 Publish DD w/o ranging (solicited) 1576 Subscribe EE w/ ranging (passive) 1577 Subscribe FF w/ ranging (active) 1578 DUT2: start multiple services 1579 Subscribe AA w/ ranging (passive) 1580 Publish BB w/ ranging (solicited) 1581 Subscribe DD w/o ranging (active) 1582 Expect 1583 DUT2: AA match w/ range information 1584 DUT1: BB match w/o range information (concurrency disables ranging) 1585 DUT2: DD match w/o range information 1586 DUT1: Terminate AA 1587 DUT2: 1588 Terminate AA 1589 Start Publish EE w/ ranging (unsolicited) 1590 DUT1: expect EE w/o ranging 1591 DUT1: Terminate CC 1592 DUT2: Start Publish FF w/ ranging (solicited) 1593 DUT1: expect FF w/ ranging information - should finally be back up 1594 """ 1595 dut1 = self.android_devices[0] 1596 dut1.pretty_name = "DUT1" 1597 dut2 = self.android_devices[1] 1598 dut2.pretty_name = "DUT2" 1599 1600 # Publisher+Subscriber: attach and wait for confirmation 1601 dut1_id = dut1.droid.wifiAwareAttach(False) 1602 autils.wait_for_event(dut1, aconsts.EVENT_CB_ON_ATTACHED) 1603 time.sleep(self.device_startup_offset) 1604 dut2_id = dut2.droid.wifiAwareAttach(False) 1605 autils.wait_for_event(dut2, aconsts.EVENT_CB_ON_ATTACHED) 1606 1607 # DUT1: initial service bringup 1608 aa_p_id = dut1.droid.wifiAwarePublish( 1609 dut1_id, 1610 autils.add_ranging_to_pub( 1611 autils.create_discovery_config( 1612 "AA", aconsts.PUBLISH_TYPE_UNSOLICITED), 1613 enable_ranging=True), True) 1614 autils.wait_for_event( 1615 dut1, 1616 autils.decorate_event(aconsts.SESSION_CB_ON_PUBLISH_STARTED, 1617 aa_p_id)) 1618 bb_s_id = dut1.droid.wifiAwareSubscribe( 1619 dut1_id, 1620 autils.add_ranging_to_sub( 1621 autils.create_discovery_config("BB", 1622 aconsts.SUBSCRIBE_TYPE_ACTIVE), 1623 min_distance_mm=None, 1624 max_distance_mm=1000000), True) 1625 autils.wait_for_event( 1626 dut1, 1627 autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED, 1628 bb_s_id)) 1629 cc_p_id = dut1.droid.wifiAwarePublish( 1630 dut1_id, 1631 autils.add_ranging_to_pub( 1632 autils.create_discovery_config( 1633 "CC", aconsts.PUBLISH_TYPE_UNSOLICITED), 1634 enable_ranging=True), True) 1635 autils.wait_for_event( 1636 dut1, 1637 autils.decorate_event(aconsts.SESSION_CB_ON_PUBLISH_STARTED, 1638 cc_p_id)) 1639 dd_p_id = dut1.droid.wifiAwarePublish( 1640 dut1_id, 1641 autils.create_discovery_config( 1642 "DD", aconsts.PUBLISH_TYPE_SOLICITED), True) 1643 autils.wait_for_event( 1644 dut1, 1645 autils.decorate_event(aconsts.SESSION_CB_ON_PUBLISH_STARTED, 1646 dd_p_id)) 1647 ee_s_id = dut1.droid.wifiAwareSubscribe( 1648 dut1_id, 1649 autils.add_ranging_to_sub( 1650 autils.create_discovery_config("EE", 1651 aconsts.SUBSCRIBE_TYPE_PASSIVE), 1652 min_distance_mm=None, 1653 max_distance_mm=1000000), True) 1654 autils.wait_for_event( 1655 dut1, 1656 autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED, 1657 ee_s_id)) 1658 ff_s_id = dut1.droid.wifiAwareSubscribe( 1659 dut1_id, 1660 autils.add_ranging_to_sub( 1661 autils.create_discovery_config("FF", 1662 aconsts.SUBSCRIBE_TYPE_ACTIVE), 1663 min_distance_mm=None, 1664 max_distance_mm=1000000), True) 1665 autils.wait_for_event( 1666 dut1, 1667 autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED, 1668 ff_s_id)) 1669 1670 # DUT2: initial service bringup 1671 aa_s_id = dut2.droid.wifiAwareSubscribe( 1672 dut2_id, 1673 autils.add_ranging_to_sub( 1674 autils.create_discovery_config("AA", 1675 aconsts.SUBSCRIBE_TYPE_PASSIVE), 1676 min_distance_mm=None, 1677 max_distance_mm=1000000), True) 1678 autils.wait_for_event( 1679 dut2, 1680 autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED, 1681 aa_s_id)) 1682 bb_p_id = dut2.droid.wifiAwarePublish( 1683 dut2_id, 1684 autils.add_ranging_to_pub( 1685 autils.create_discovery_config("BB", 1686 aconsts.PUBLISH_TYPE_SOLICITED), 1687 enable_ranging=True), True) 1688 autils.wait_for_event( 1689 dut2, 1690 autils.decorate_event(aconsts.SESSION_CB_ON_PUBLISH_STARTED, 1691 bb_p_id)) 1692 dd_s_id = dut2.droid.wifiAwareSubscribe( 1693 dut2_id, 1694 autils.create_discovery_config( 1695 "AA", aconsts.SUBSCRIBE_TYPE_ACTIVE), True) 1696 autils.wait_for_event( 1697 dut2, 1698 autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED, 1699 dd_s_id)) 1700 1701 # Initial set of discovery events for AA, BB, and DD (which are up) 1702 event = autils.wait_for_event( 1703 dut2, 1704 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1705 aa_s_id)) 1706 asserts.assert_true( 1707 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 1708 "Discovery with ranging for AA expected!") 1709 event = autils.wait_for_event( 1710 dut1, 1711 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1712 bb_s_id)) 1713 if self.RANGING_INITIATOR_RESPONDER_CONCURRENCY_LIMITATION: 1714 asserts.assert_false( 1715 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 1716 "Discovery with ranging for BB NOT expected!") 1717 else: 1718 asserts.assert_true( 1719 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 1720 "Discovery with ranging for BB expected!") 1721 event = autils.wait_for_event( 1722 dut2, 1723 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1724 dd_s_id)) 1725 asserts.assert_false( 1726 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 1727 "Discovery with ranging for DD NOT expected!") 1728 1729 # DUT1/DUT2: terminate AA 1730 dut1.droid.wifiAwareDestroyDiscoverySession(aa_p_id) 1731 dut2.droid.wifiAwareDestroyDiscoverySession(aa_s_id) 1732 1733 time.sleep( 1734 5) # guarantee that session terminated (and host recovered?) 1735 1736 # DUT2: try EE service - ranging still disabled 1737 ee_p_id = dut2.droid.wifiAwarePublish( 1738 dut2_id, 1739 autils.add_ranging_to_pub( 1740 autils.create_discovery_config( 1741 "EE", aconsts.PUBLISH_TYPE_UNSOLICITED), 1742 enable_ranging=True), True) 1743 autils.wait_for_event( 1744 dut2, 1745 autils.decorate_event(aconsts.SESSION_CB_ON_PUBLISH_STARTED, 1746 ee_p_id)) 1747 1748 event = autils.wait_for_event( 1749 dut1, 1750 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1751 ee_s_id)) 1752 if self.RANGING_INITIATOR_RESPONDER_CONCURRENCY_LIMITATION: 1753 asserts.assert_false( 1754 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 1755 "Discovery with ranging for EE NOT expected!") 1756 else: 1757 asserts.assert_true( 1758 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 1759 "Discovery with ranging for EE expected!") 1760 1761 # DUT1: terminate CC - last publish w/ ranging on DUT! 1762 dut1.droid.wifiAwareDestroyDiscoverySession(cc_p_id) 1763 1764 time.sleep( 1765 5) # guarantee that session terminated (and host recovered?) 1766 1767 # DUT2: try FF service - ranging should now function 1768 ff_p_id = dut2.droid.wifiAwarePublish( 1769 dut2_id, 1770 autils.add_ranging_to_pub( 1771 autils.create_discovery_config("FF", 1772 aconsts.PUBLISH_TYPE_SOLICITED), 1773 enable_ranging=True), True) 1774 autils.wait_for_event( 1775 dut2, 1776 autils.decorate_event(aconsts.SESSION_CB_ON_PUBLISH_STARTED, 1777 ff_p_id)) 1778 1779 event = autils.wait_for_event( 1780 dut1, 1781 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1782 ff_s_id)) 1783 asserts.assert_true( 1784 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 1785 "Discovery with ranging for FF expected!") 1786 1787 @test_tracker_info(uuid="6700eab8-a172-43cd-aed3-e6577ce8fd89") 1788 def test_discovery_direct_concurrency(self): 1789 """Verify the behavior of Wi-Fi Aware Ranging used as part of discovery and 1790 as direct ranging to a peer device. 1791 1792 Process: 1793 - Start YYY service with ranging in-range 1794 - Start XXX service with ranging out-of-range 1795 - Start performing direct Ranging 1796 - While above going on update XXX to be in-range 1797 - Keep performing direct Ranging in context of YYY 1798 - Stop direct Ranging and look for XXX to discover 1799 """ 1800 dut1 = self.android_devices[0] 1801 dut1.pretty_name = "DUT1" 1802 dut2 = self.android_devices[1] 1803 dut2.pretty_name = "DUT2" 1804 1805 # DUTs: attach and wait for confirmation 1806 dut1_id = dut1.droid.wifiAwareAttach(False) 1807 autils.wait_for_event(dut1, aconsts.EVENT_CB_ON_ATTACHED) 1808 time.sleep(self.device_startup_offset) 1809 dut2_id = dut2.droid.wifiAwareAttach(True) 1810 event = autils.wait_for_event(dut2, 1811 aconsts.EVENT_CB_ON_IDENTITY_CHANGED) 1812 dut2_mac = event['data']['mac'] 1813 1814 # DUT1: publishers bring-up 1815 xxx_p_id = dut1.droid.wifiAwarePublish( 1816 dut1_id, 1817 autils.add_ranging_to_pub( 1818 autils.create_discovery_config( 1819 "XXX", aconsts.PUBLISH_TYPE_UNSOLICITED), 1820 enable_ranging=True), True) 1821 autils.wait_for_event( 1822 dut1, 1823 autils.decorate_event(aconsts.SESSION_CB_ON_PUBLISH_STARTED, 1824 xxx_p_id)) 1825 yyy_p_id = dut1.droid.wifiAwarePublish( 1826 dut1_id, 1827 autils.add_ranging_to_pub( 1828 autils.create_discovery_config( 1829 "YYY", aconsts.PUBLISH_TYPE_UNSOLICITED), 1830 enable_ranging=True), True) 1831 autils.wait_for_event( 1832 dut1, 1833 autils.decorate_event(aconsts.SESSION_CB_ON_PUBLISH_STARTED, 1834 yyy_p_id)) 1835 1836 # DUT2: subscribers bring-up 1837 xxx_s_id = dut2.droid.wifiAwareSubscribe( 1838 dut2_id, 1839 autils.add_ranging_to_sub( 1840 autils.create_discovery_config("XXX", 1841 aconsts.SUBSCRIBE_TYPE_PASSIVE), 1842 min_distance_mm=1000000, 1843 max_distance_mm=1000001), True) 1844 autils.wait_for_event( 1845 dut2, 1846 autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED, 1847 xxx_s_id)) 1848 yyy_s_id = dut2.droid.wifiAwareSubscribe( 1849 dut2_id, 1850 autils.add_ranging_to_sub( 1851 autils.create_discovery_config("YYY", 1852 aconsts.SUBSCRIBE_TYPE_PASSIVE), 1853 min_distance_mm=None, 1854 max_distance_mm=1000000), True) 1855 autils.wait_for_event( 1856 dut2, 1857 autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED, 1858 yyy_s_id)) 1859 1860 # Service discovery: YYY (with range info), but no XXX 1861 event = autils.wait_for_event( 1862 dut2, 1863 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1864 yyy_s_id)) 1865 asserts.assert_true( 1866 aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"], 1867 "Discovery with ranging for YYY expected!") 1868 yyy_peer_id_on_sub = event['data'][aconsts.SESSION_CB_KEY_PEER_ID] 1869 1870 autils.fail_on_event( 1871 dut2, 1872 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1873 xxx_s_id)) 1874 1875 # Direct ranging 1876 results21 = [] 1877 for iter in range(10): 1878 id = dut2.droid.wifiRttStartRangingToAwarePeerId( 1879 yyy_peer_id_on_sub) 1880 event = autils.wait_for_event( 1881 dut2, 1882 rutils.decorate_event(rconsts.EVENT_CB_RANGING_ON_RESULT, id)) 1883 results21.append( 1884 event["data"][rconsts.EVENT_CB_RANGING_KEY_RESULTS][0]) 1885 1886 time.sleep(5) # while switching roles 1887 1888 results12 = [] 1889 for iter in range(10): 1890 id = dut1.droid.wifiRttStartRangingToAwarePeerMac(dut2_mac) 1891 event = autils.wait_for_event( 1892 dut1, 1893 rutils.decorate_event(rconsts.EVENT_CB_RANGING_ON_RESULT, id)) 1894 results12.append( 1895 event["data"][rconsts.EVENT_CB_RANGING_KEY_RESULTS][0]) 1896 1897 stats = [ 1898 rutils.extract_stats(results12, 0, 0, 0), 1899 rutils.extract_stats(results21, 0, 0, 0) 1900 ] 1901 1902 # Update XXX to be within range 1903 dut2.droid.wifiAwareUpdateSubscribe( 1904 xxx_s_id, 1905 autils.add_ranging_to_sub( 1906 autils.create_discovery_config("XXX", 1907 aconsts.SUBSCRIBE_TYPE_PASSIVE), 1908 min_distance_mm=None, 1909 max_distance_mm=1000000)) 1910 autils.wait_for_event( 1911 dut2, 1912 autils.decorate_event(aconsts.SESSION_CB_ON_SESSION_CONFIG_UPDATED, 1913 xxx_s_id)) 1914 1915 # Expect discovery on XXX - wait until discovery with ranging: 1916 # - 0 or more: without ranging info (due to concurrency limitations) 1917 # - 1 or more: with ranging (once concurrency limitation relieved) 1918 num_events = 0 1919 while True: 1920 event = autils.wait_for_event( 1921 dut2, 1922 autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, 1923 xxx_s_id)) 1924 if aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"]: 1925 break 1926 num_events = num_events + 1 1927 asserts.assert_true( 1928 num_events < 10, # arbitrary safety valve 1929 "Way too many discovery events without ranging!") 1930 1931 asserts.explicit_pass( 1932 "Discovery/Direct RTT Concurrency Pass", extras={"data": stats}) 1933