1 /* 2 * Copyright (C) 2017, The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <vector> 18 19 #include <gmock/gmock.h> 20 #include <gtest/gtest.h> 21 #include <wifi_system_test/mock_interface_tool.h> 22 #include <wifi_system_test/mock_supplicant_manager.h> 23 24 #include "android/net/wifi/IWifiScannerImpl.h" 25 #include "wificond/scanning/offload/offload_scan_utils.h" 26 #include "wificond/scanning/scanner_impl.h" 27 #include "wificond/tests/mock_client_interface_impl.h" 28 #include "wificond/tests/mock_netlink_manager.h" 29 #include "wificond/tests/mock_netlink_utils.h" 30 #include "wificond/tests/mock_offload_scan_callback_interface_impl.h" 31 #include "wificond/tests/mock_offload_scan_manager.h" 32 #include "wificond/tests/mock_offload_service_utils.h" 33 #include "wificond/tests/mock_scan_utils.h" 34 #include "wificond/tests/offload_test_utils.h" 35 36 using ::android::binder::Status; 37 using ::android::net::wifi::IWifiScannerImpl; 38 using ::android::wifi_system::MockInterfaceTool; 39 using ::com::android::server::wifi::wificond::SingleScanSettings; 40 using ::com::android::server::wifi::wificond::PnoSettings; 41 using ::com::android::server::wifi::wificond::NativeScanResult; 42 using android::hardware::wifi::offload::V1_0::ScanResult; 43 using ::testing::Invoke; 44 using ::testing::NiceMock; 45 using ::testing::Return; 46 using ::testing::_; 47 using std::shared_ptr; 48 using std::unique_ptr; 49 using std::vector; 50 51 using namespace std::placeholders; 52 53 namespace android { 54 namespace wificond { 55 56 namespace { 57 58 constexpr uint32_t kFakeInterfaceIndex = 12; 59 constexpr uint32_t kFakeScanIntervalMs = 10000; 60 61 // This is a helper function to mock the behavior of ScanUtils::Scan() 62 // when we expect a error code. 63 // |interface_index_ignored|, |request_random_mac_ignored|, |ssids_ignored|, 64 // |freqs_ignored|, |error_code| are mapped to existing parameters of ScanUtils::Scan(). 65 // |mock_error_code| is a additional parameter used for specifying expected error code. 66 bool ReturnErrorCodeForScanRequest( 67 int mock_error_code, 68 uint32_t interface_index_ignored, 69 bool request_random_mac_ignored, 70 int scan_type, 71 const std::vector<std::vector<uint8_t>>& ssids_ignored, 72 const std::vector<uint32_t>& freqs_ignored, 73 int* error_code) { 74 *error_code = mock_error_code; 75 // Returing false because this helper function is used for failure case. 76 return false; 77 } 78 79 bool CaptureSchedScanIntervalSetting( 80 uint32_t /* interface_index */, 81 const SchedScanIntervalSetting& interval_setting, 82 int32_t /* rssi_threshold_2g */, 83 int32_t /* rssi_threshold_5g */, 84 bool /* request_random_mac */, 85 bool /* request_low_power_scan */, 86 const std::vector<std::vector<uint8_t>>& /* scan_ssids */, 87 const std::vector<std::vector<uint8_t>>& /* match_ssids */, 88 const std::vector<uint32_t>& /* freqs */, 89 int* /* error_code */, 90 SchedScanIntervalSetting* out_interval_setting) { 91 *out_interval_setting = interval_setting; 92 return true; 93 } 94 95 bool ReturnOffloadScanResults( 96 std::vector<NativeScanResult>* native_scan_results_, 97 const std::vector<ScanResult>& offload_scan_results) { 98 return OffloadScanUtils::convertToNativeScanResults(offload_scan_results, 99 native_scan_results_); 100 } 101 102 bool ReturnNetlinkScanResults( 103 uint32_t interface_index, 104 std::vector<NativeScanResult>* native_scan_results_, 105 const std::vector<ScanResult>& offload_scan_results) { 106 return OffloadScanUtils::convertToNativeScanResults(offload_scan_results, 107 native_scan_results_); 108 } 109 110 } // namespace 111 112 class ScannerTest : public ::testing::Test { 113 protected: 114 void SetUp() override { 115 ON_CALL(*offload_service_utils_, GetOffloadScanManager(_, _)) 116 .WillByDefault(Return(offload_scan_manager_)); 117 ON_CALL(*offload_service_utils_, GetOffloadScanCallbackInterface(_)) 118 .WillByDefault(Return(offload_scan_callback_interface_)); 119 dummy_scan_results_ = OffloadTestUtils::createOffloadScanResults(); 120 } 121 122 void TearDown() override { dummy_scan_results_.clear(); } 123 124 unique_ptr<ScannerImpl> scanner_impl_; 125 NiceMock<MockNetlinkManager> netlink_manager_; 126 NiceMock<MockNetlinkUtils> netlink_utils_{&netlink_manager_}; 127 NiceMock<MockScanUtils> scan_utils_{&netlink_manager_}; 128 NiceMock<MockInterfaceTool> if_tool_; 129 NiceMock<MockClientInterfaceImpl> client_interface_impl_{ 130 &if_tool_, &netlink_utils_, &scan_utils_}; 131 shared_ptr<NiceMock<MockOffloadServiceUtils>> offload_service_utils_{ 132 new NiceMock<MockOffloadServiceUtils>()}; 133 shared_ptr<NiceMock<MockOffloadScanCallbackInterfaceImpl>> 134 offload_scan_callback_interface_{ 135 new NiceMock<MockOffloadScanCallbackInterfaceImpl>( 136 scanner_impl_.get())}; 137 std::shared_ptr<NiceMock<MockOffloadScanManager>> offload_scan_manager_{ 138 new NiceMock<MockOffloadScanManager>(offload_service_utils_, 139 offload_scan_callback_interface_)}; 140 ScanCapabilities scan_capabilities_; 141 WiphyFeatures wiphy_features_; 142 std::vector<ScanResult> dummy_scan_results_; 143 }; 144 145 TEST_F(ScannerTest, TestSingleScan) { 146 EXPECT_CALL(scan_utils_, 147 Scan(_, _, IWifiScannerImpl::SCAN_TYPE_DEFAULT, _, _, _)). 148 WillOnce(Return(true)); 149 bool success = false; 150 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 151 scan_capabilities_, wiphy_features_, 152 &client_interface_impl_, 153 &scan_utils_, offload_service_utils_)); 154 EXPECT_TRUE(scanner_impl_->scan(SingleScanSettings(), &success).isOk()); 155 EXPECT_TRUE(success); 156 } 157 158 TEST_F(ScannerTest, TestSingleScanForLowSpanScan) { 159 EXPECT_CALL(scan_utils_, 160 Scan(_, _, IWifiScannerImpl::SCAN_TYPE_LOW_SPAN, _, _, _)). 161 WillOnce(Return(true)); 162 wiphy_features_.supports_low_span_oneshot_scan = true; 163 ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_, 164 wiphy_features_, &client_interface_impl_, 165 &scan_utils_, offload_service_utils_); 166 SingleScanSettings settings; 167 settings.scan_type_ = IWifiScannerImpl::SCAN_TYPE_LOW_SPAN; 168 bool success = false; 169 EXPECT_TRUE(scanner_impl.scan(settings, &success).isOk()); 170 EXPECT_TRUE(success); 171 } 172 173 TEST_F(ScannerTest, TestSingleScanForLowPowerScan) { 174 EXPECT_CALL(scan_utils_, 175 Scan(_, _, IWifiScannerImpl::SCAN_TYPE_LOW_POWER, _, _, _)). 176 WillOnce(Return(true)); 177 wiphy_features_.supports_low_power_oneshot_scan = true; 178 ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_, 179 wiphy_features_, &client_interface_impl_, 180 &scan_utils_, offload_service_utils_); 181 SingleScanSettings settings; 182 settings.scan_type_ = IWifiScannerImpl::SCAN_TYPE_LOW_POWER; 183 bool success = false; 184 EXPECT_TRUE(scanner_impl.scan(settings, &success).isOk()); 185 EXPECT_TRUE(success); 186 } 187 188 TEST_F(ScannerTest, TestSingleScanForHighAccuracyScan) { 189 EXPECT_CALL(scan_utils_, 190 Scan(_, _, IWifiScannerImpl::SCAN_TYPE_HIGH_ACCURACY, _, _, _)). 191 WillOnce(Return(true)); 192 wiphy_features_.supports_high_accuracy_oneshot_scan = true; 193 ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_, 194 wiphy_features_, &client_interface_impl_, 195 &scan_utils_, offload_service_utils_); 196 SingleScanSettings settings; 197 settings.scan_type_ = IWifiScannerImpl::SCAN_TYPE_HIGH_ACCURACY; 198 bool success = false; 199 EXPECT_TRUE(scanner_impl.scan(settings, &success).isOk()); 200 EXPECT_TRUE(success); 201 } 202 203 TEST_F(ScannerTest, TestSingleScanForLowSpanScanWithNoWiphySupport) { 204 EXPECT_CALL(scan_utils_, 205 Scan(_, _, IWifiScannerImpl::SCAN_TYPE_DEFAULT, _, _, _)). 206 WillOnce(Return(true)); 207 ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_, 208 wiphy_features_, &client_interface_impl_, 209 &scan_utils_, offload_service_utils_); 210 SingleScanSettings settings; 211 settings.scan_type_ = IWifiScannerImpl::SCAN_TYPE_LOW_SPAN; 212 bool success = false; 213 EXPECT_TRUE(scanner_impl.scan(settings, &success).isOk()); 214 EXPECT_TRUE(success); 215 } 216 217 TEST_F(ScannerTest, TestSingleScanForLowPowerScanWithNoWiphySupport) { 218 EXPECT_CALL(scan_utils_, 219 Scan(_, _, IWifiScannerImpl::SCAN_TYPE_DEFAULT, _, _, _)). 220 WillOnce(Return(true)); 221 ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_, 222 wiphy_features_, &client_interface_impl_, 223 &scan_utils_, offload_service_utils_); 224 SingleScanSettings settings; 225 settings.scan_type_ = IWifiScannerImpl::SCAN_TYPE_LOW_POWER; 226 bool success = false; 227 EXPECT_TRUE(scanner_impl.scan(settings, &success).isOk()); 228 EXPECT_TRUE(success); 229 } 230 231 TEST_F(ScannerTest, TestSingleScanForHighAccuracyScanWithNoWiphySupport) { 232 EXPECT_CALL(scan_utils_, 233 Scan(_, _, IWifiScannerImpl::SCAN_TYPE_DEFAULT, _, _, _)). 234 WillOnce(Return(true)); 235 ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_, 236 wiphy_features_, &client_interface_impl_, 237 &scan_utils_, offload_service_utils_); 238 SingleScanSettings settings; 239 settings.scan_type_ = IWifiScannerImpl::SCAN_TYPE_HIGH_ACCURACY; 240 bool success = false; 241 EXPECT_TRUE(scanner_impl.scan(settings, &success).isOk()); 242 EXPECT_TRUE(success); 243 } 244 245 TEST_F(ScannerTest, TestSingleScanFailure) { 246 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 247 scan_capabilities_, wiphy_features_, 248 &client_interface_impl_, 249 &scan_utils_, offload_service_utils_)); 250 EXPECT_CALL( 251 scan_utils_, 252 Scan(_, _, _, _, _, _)). 253 WillOnce(Invoke(bind( 254 ReturnErrorCodeForScanRequest, EBUSY, 255 _1, _2, _3, _4, _5, _6))); 256 257 bool success = false; 258 EXPECT_TRUE(scanner_impl_->scan(SingleScanSettings(), &success).isOk()); 259 EXPECT_FALSE(success); 260 } 261 262 TEST_F(ScannerTest, TestProcessAbortsOnScanReturningNoDeviceError) { 263 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 264 scan_capabilities_, wiphy_features_, 265 &client_interface_impl_, 266 &scan_utils_, offload_service_utils_)); 267 ON_CALL( 268 scan_utils_, 269 Scan(_, _, _, _, _, _)). 270 WillByDefault(Invoke(bind( 271 ReturnErrorCodeForScanRequest, ENODEV, 272 _1, _2, _3, _4, _5, _6))); 273 274 bool success_ignored; 275 EXPECT_DEATH(scanner_impl_->scan(SingleScanSettings(), &success_ignored), 276 "Driver is in a bad state*"); 277 } 278 279 TEST_F(ScannerTest, TestAbortScan) { 280 bool single_scan_success = false; 281 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 282 scan_capabilities_, wiphy_features_, 283 &client_interface_impl_, 284 &scan_utils_, offload_service_utils_)); 285 EXPECT_CALL(scan_utils_, Scan(_, _, _, _, _, _)) 286 .WillOnce(Return(true)); 287 EXPECT_TRUE( 288 scanner_impl_->scan(SingleScanSettings(), &single_scan_success).isOk()); 289 EXPECT_TRUE(single_scan_success); 290 291 EXPECT_CALL(scan_utils_, AbortScan(_)); 292 EXPECT_TRUE(scanner_impl_->abortScan().isOk()); 293 } 294 295 TEST_F(ScannerTest, TestAbortScanNotIssuedIfNoOngoingScan) { 296 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 297 scan_capabilities_, wiphy_features_, 298 &client_interface_impl_, 299 &scan_utils_, offload_service_utils_)); 300 EXPECT_CALL(scan_utils_, AbortScan(_)).Times(0); 301 EXPECT_TRUE(scanner_impl_->abortScan().isOk()); 302 } 303 304 TEST_F(ScannerTest, TestGetScanResults) { 305 vector<NativeScanResult> scan_results; 306 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 307 scan_capabilities_, wiphy_features_, 308 &client_interface_impl_, 309 &scan_utils_, offload_service_utils_)); 310 EXPECT_CALL(scan_utils_, GetScanResult(_, _)).WillOnce(Return(true)); 311 EXPECT_TRUE(scanner_impl_->getScanResults(&scan_results).isOk()); 312 } 313 314 TEST_F(ScannerTest, TestStartPnoScanViaNetlink) { 315 bool success = false; 316 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported()) 317 .Times(1) 318 .WillRepeatedly(Return(false)); 319 ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_, 320 wiphy_features_, &client_interface_impl_, 321 &scan_utils_, offload_service_utils_); 322 EXPECT_CALL( 323 scan_utils_, 324 StartScheduledScan(_, _, _, _, _, false, _, _, _, _)). 325 WillOnce(Return(true)); 326 EXPECT_TRUE(scanner_impl.startPnoScan(PnoSettings(), &success).isOk()); 327 EXPECT_TRUE(success); 328 } 329 330 TEST_F(ScannerTest, TestStartPnoScanViaNetlinkWithLowPowerScanWiphySupport) { 331 bool success = false; 332 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported()) 333 .Times(1) 334 .WillRepeatedly(Return(false)); 335 wiphy_features_.supports_low_power_oneshot_scan = true; 336 ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_, 337 wiphy_features_, &client_interface_impl_, 338 &scan_utils_, offload_service_utils_); 339 EXPECT_CALL( 340 scan_utils_, 341 StartScheduledScan(_, _, _, _, _, true, _, _, _, _)). 342 WillOnce(Return(true)); 343 EXPECT_TRUE(scanner_impl.startPnoScan(PnoSettings(), &success).isOk()); 344 EXPECT_TRUE(success); 345 } 346 347 TEST_F(ScannerTest, TestStopPnoScanViaNetlink) { 348 bool success = false; 349 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported()) 350 .Times(1) 351 .WillRepeatedly(Return(false)); 352 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 353 scan_capabilities_, wiphy_features_, 354 &client_interface_impl_, 355 &scan_utils_, offload_service_utils_)); 356 // StopScheduledScan() will be called no matter if there is an ongoing 357 // scheduled scan or not. This is for making the system more robust. 358 EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true)); 359 EXPECT_TRUE(scanner_impl_->stopPnoScan(&success).isOk()); 360 EXPECT_TRUE(success); 361 } 362 363 TEST_F(ScannerTest, TestStartScanOverOffload) { 364 bool success = false; 365 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported()) 366 .Times(1) 367 .WillRepeatedly(Return(true)); 368 EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _)) 369 .Times(1) 370 .WillRepeatedly(Return(true)); 371 EXPECT_CALL(*offload_scan_manager_, stopScan(_)) 372 .Times(1) 373 .WillRepeatedly(Return(true)); 374 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 375 scan_capabilities_, wiphy_features_, 376 &client_interface_impl_, 377 &scan_utils_, offload_service_utils_)); 378 scanner_impl_->startPnoScan(PnoSettings(), &success); 379 EXPECT_TRUE(success); 380 scanner_impl_->stopPnoScan(&success); 381 EXPECT_TRUE(success); 382 } 383 384 TEST_F(ScannerTest, TestStartScanOverNetlinkFallback) { 385 bool success = false; 386 ON_CALL(*offload_service_utils_, IsOffloadScanSupported()) 387 .WillByDefault(Return(true)); 388 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 389 scan_capabilities_, wiphy_features_, 390 &client_interface_impl_, 391 &scan_utils_, offload_service_utils_)); 392 EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _)) 393 .WillOnce(Return(false)); 394 EXPECT_CALL(*offload_scan_manager_, stopScan(_)).Times(0); 395 EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _, _, _)) 396 .WillOnce(Return(true)); 397 EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true)); 398 EXPECT_TRUE(scanner_impl_->startPnoScan(PnoSettings(), &success).isOk()); 399 EXPECT_TRUE(success == true); 400 scanner_impl_->stopPnoScan(&success); 401 EXPECT_TRUE(success); 402 } 403 404 TEST_F(ScannerTest, TestAsyncErrorOverOffload) { 405 bool success = false; 406 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported()) 407 .Times(1) 408 .WillRepeatedly(Return(true)); 409 EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _)) 410 .Times(1) 411 .WillRepeatedly(Return(true)); 412 EXPECT_CALL(*offload_scan_manager_, stopScan(_)) 413 .Times(1) 414 .WillRepeatedly(Return(true)); 415 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 416 scan_capabilities_, wiphy_features_, 417 &client_interface_impl_, 418 &scan_utils_, offload_service_utils_)); 419 EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _, _, _)) 420 .WillOnce(Return(true)); 421 EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true)); 422 scanner_impl_->startPnoScan(PnoSettings(), &success); 423 EXPECT_TRUE(success); 424 scanner_impl_->OnOffloadError( 425 OffloadScanCallbackInterface::AsyncErrorReason::REMOTE_FAILURE); 426 scanner_impl_->stopPnoScan(&success); 427 EXPECT_TRUE(success); 428 } 429 430 TEST_F(ScannerTest, TestGetScanResultsFromOffload) { 431 bool success = false; 432 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported()) 433 .Times(1) 434 .WillRepeatedly(Return(true)); 435 EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _)) 436 .Times(1) 437 .WillRepeatedly(Return(true)); 438 EXPECT_CALL(*offload_scan_manager_, getScanResults(_)) 439 .Times(1) 440 .WillOnce( 441 Invoke(bind(ReturnOffloadScanResults, _1, dummy_scan_results_))); 442 EXPECT_CALL(*offload_scan_manager_, stopScan(_)) 443 .Times(1) 444 .WillRepeatedly(Return(true)); 445 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 446 scan_capabilities_, wiphy_features_, 447 &client_interface_impl_, 448 &scan_utils_, offload_service_utils_)); 449 scanner_impl_->startPnoScan(PnoSettings(), &success); 450 EXPECT_TRUE(success); 451 scanner_impl_->OnOffloadScanResult(); 452 std::vector<NativeScanResult> scan_results; 453 EXPECT_TRUE(scanner_impl_->getPnoScanResults(&scan_results).isOk()); 454 EXPECT_FALSE(scan_results.empty()); 455 scanner_impl_->stopPnoScan(&success); 456 EXPECT_TRUE(success); 457 } 458 459 TEST_F(ScannerTest, TestGetScanResultsWhenOffloadFails) { 460 bool success = false; 461 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported()) 462 .Times(1) 463 .WillRepeatedly(Return(true)); 464 EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _)) 465 .Times(1) 466 .WillRepeatedly(Return(true)); 467 EXPECT_CALL(*offload_scan_manager_, stopScan(_)) 468 .Times(1) 469 .WillRepeatedly(Return(true)); 470 EXPECT_CALL(*offload_scan_manager_, getScanResults(_)).Times(0); 471 EXPECT_CALL(scan_utils_, GetScanResult(_, _)) 472 .Times(1) 473 .WillOnce( 474 Invoke(bind(ReturnNetlinkScanResults, _1, _2, dummy_scan_results_))); 475 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 476 scan_capabilities_, wiphy_features_, 477 &client_interface_impl_, 478 &scan_utils_, offload_service_utils_)); 479 EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _, _, _)) 480 .WillOnce(Return(true)); 481 EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true)); 482 EXPECT_TRUE(scanner_impl_->startPnoScan(PnoSettings(), &success).isOk()); 483 EXPECT_TRUE(success); 484 scanner_impl_->OnOffloadError( 485 OffloadScanCallbackInterface::AsyncErrorReason::REMOTE_FAILURE); 486 std::vector<NativeScanResult> scan_results; 487 EXPECT_TRUE(scanner_impl_->getPnoScanResults(&scan_results).isOk()); 488 EXPECT_FALSE(scan_results.empty()); 489 scanner_impl_->stopPnoScan(&success); 490 EXPECT_TRUE(success); 491 } 492 493 TEST_F(ScannerTest, TestGenerateScanPlansIfDeviceSupports) { 494 ScanCapabilities scan_capabilities_scan_plan_supported( 495 0 /* max_num_scan_ssids */, 496 0 /* max_num_sched_scan_ssids */, 497 0 /* max_match_sets */, 498 // Parameters above are not related to this test. 499 2 /* 1 plan for finite repeated scan and 1 plan for ininfite scan loop */, 500 kFakeScanIntervalMs * PnoSettings::kSlowScanIntervalMultiplier / 1000, 501 PnoSettings::kFastScanIterations); 502 ScannerImpl scanner( 503 kFakeInterfaceIndex, 504 scan_capabilities_scan_plan_supported, wiphy_features_, 505 &client_interface_impl_, 506 &scan_utils_, offload_service_utils_); 507 508 PnoSettings pno_settings; 509 pno_settings.interval_ms_ = kFakeScanIntervalMs; 510 511 SchedScanIntervalSetting interval_setting; 512 EXPECT_CALL( 513 scan_utils_, 514 StartScheduledScan(_, _, _, _, _, _, _, _, _, _)). 515 WillOnce(Invoke(bind( 516 CaptureSchedScanIntervalSetting, 517 _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, &interval_setting))); 518 519 bool success_ignored = 0; 520 EXPECT_TRUE(scanner.startPnoScan(pno_settings, &success_ignored).isOk()); 521 /* 1 plan for finite repeated scan */ 522 EXPECT_EQ(1U, interval_setting.plans.size()); 523 EXPECT_EQ(kFakeScanIntervalMs * PnoSettings::kSlowScanIntervalMultiplier, 524 interval_setting.final_interval_ms); 525 } 526 527 TEST_F(ScannerTest, TestGenerateSingleIntervalIfDeviceDoesNotSupportScanPlan) { 528 ScanCapabilities scan_capabilities_no_scan_plan_support( 529 0 /* max_num_scan_ssids */, 530 0 /* max_num_sched_scan_ssids */, 531 0 /* max_match_sets */, 532 // Parameters above are not related to this test. 533 0 /* max_num_scan_plans */, 534 0 /* max_scan_plan_interval */, 535 0 /* max_scan_plan_iterations */); 536 ScannerImpl scanner( 537 kFakeInterfaceIndex, 538 scan_capabilities_no_scan_plan_support, wiphy_features_, 539 &client_interface_impl_, 540 &scan_utils_, offload_service_utils_); 541 PnoSettings pno_settings; 542 pno_settings.interval_ms_ = kFakeScanIntervalMs; 543 544 SchedScanIntervalSetting interval_setting; 545 EXPECT_CALL( 546 scan_utils_, 547 StartScheduledScan(_, _, _, _, _, _, _, _, _, _)). 548 WillOnce(Invoke(bind( 549 CaptureSchedScanIntervalSetting, 550 _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, &interval_setting))); 551 552 bool success_ignored = 0; 553 EXPECT_TRUE(scanner.startPnoScan(pno_settings, &success_ignored).isOk()); 554 555 EXPECT_EQ(0U, interval_setting.plans.size()); 556 EXPECT_EQ(kFakeScanIntervalMs, interval_setting.final_interval_ms); 557 } 558 559 } // namespace wificond 560 } // namespace android 561
