scanner_unittest.cpp revision 3e5057cb3858bd8b0d4ea01d1eb86757cced8ce4
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 "wificond/scanning/offload/offload_scan_utils.h" 25#include "wificond/scanning/scanner_impl.h" 26#include "wificond/tests/mock_client_interface_impl.h" 27#include "wificond/tests/mock_netlink_manager.h" 28#include "wificond/tests/mock_netlink_utils.h" 29#include "wificond/tests/mock_offload_scan_callback_interface_impl.h" 30#include "wificond/tests/mock_offload_scan_manager.h" 31#include "wificond/tests/mock_offload_service_utils.h" 32#include "wificond/tests/mock_scan_utils.h" 33#include "wificond/tests/offload_test_utils.h" 34 35using ::android::binder::Status; 36using ::android::wifi_system::MockInterfaceTool; 37using ::android::wifi_system::MockSupplicantManager; 38using ::com::android::server::wifi::wificond::SingleScanSettings; 39using ::com::android::server::wifi::wificond::PnoSettings; 40using ::com::android::server::wifi::wificond::NativeScanResult; 41using android::hardware::wifi::offload::V1_0::ScanResult; 42using ::testing::Invoke; 43using ::testing::NiceMock; 44using ::testing::Return; 45using ::testing::_; 46using std::shared_ptr; 47using std::unique_ptr; 48using std::vector; 49 50using namespace std::placeholders; 51 52namespace android { 53namespace wificond { 54 55namespace { 56 57constexpr uint32_t kFakeInterfaceIndex = 12; 58constexpr uint32_t kFakeScanIntervalMs = 10000; 59 60// This is a helper function to mock the behavior of ScanUtils::Scan() 61// when we expect a error code. 62// |interface_index_ignored|, |request_random_mac_ignored|, |ssids_ignored|, 63// |freqs_ignored|, |error_code| are mapped to existing parameters of ScanUtils::Scan(). 64// |mock_error_code| is a additional parameter used for specifying expected error code. 65bool ReturnErrorCodeForScanRequest( 66 int mock_error_code, 67 uint32_t interface_index_ignored, 68 bool request_random_mac_ignored, 69 const std::vector<std::vector<uint8_t>>& ssids_ignored, 70 const std::vector<uint32_t>& freqs_ignored, 71 int* error_code) { 72 *error_code = mock_error_code; 73 // Returing false because this helper function is used for failure case. 74 return false; 75} 76 77bool CaptureSchedScanIntervalSetting( 78 uint32_t /* interface_index */, 79 const SchedScanIntervalSetting& interval_setting, 80 int32_t /* rssi_threshold */, 81 bool /* request_random_mac */, 82 const std::vector<std::vector<uint8_t>>& /* scan_ssids */, 83 const std::vector<std::vector<uint8_t>>& /* match_ssids */, 84 const std::vector<uint32_t>& /* freqs */, 85 int* /* error_code */, 86 SchedScanIntervalSetting* out_interval_setting) { 87 *out_interval_setting = interval_setting; 88 return true; 89} 90 91bool ReturnOffloadScanResults( 92 std::vector<NativeScanResult>* native_scan_results_, 93 const std::vector<ScanResult>& offload_scan_results) { 94 return OffloadScanUtils::convertToNativeScanResults(offload_scan_results, 95 native_scan_results_); 96} 97 98bool ReturnNetlinkScanResults( 99 uint32_t interface_index, 100 std::vector<NativeScanResult>* native_scan_results_, 101 const std::vector<ScanResult>& offload_scan_results) { 102 return OffloadScanUtils::convertToNativeScanResults(offload_scan_results, 103 native_scan_results_); 104} 105 106} // namespace 107 108class ScannerTest : public ::testing::Test { 109 protected: 110 void SetUp() override { 111 ON_CALL(*offload_service_utils_, GetOffloadScanManager(_, _)) 112 .WillByDefault(Return(offload_scan_manager_)); 113 ON_CALL(*offload_service_utils_, GetOffloadScanCallbackInterface(_)) 114 .WillByDefault(Return(offload_scan_callback_interface_)); 115 dummy_scan_results_ = OffloadTestUtils::createOffloadScanResults(); 116 } 117 118 void TearDown() override { dummy_scan_results_.clear(); } 119 120 unique_ptr<ScannerImpl> scanner_impl_; 121 NiceMock<MockNetlinkManager> netlink_manager_; 122 NiceMock<MockNetlinkUtils> netlink_utils_{&netlink_manager_}; 123 NiceMock<MockScanUtils> scan_utils_{&netlink_manager_}; 124 NiceMock<MockInterfaceTool> if_tool_; 125 NiceMock<MockSupplicantManager> supplicant_manager_; 126 NiceMock<MockClientInterfaceImpl> client_interface_impl_{ 127 &if_tool_, &supplicant_manager_, &netlink_utils_, &scan_utils_}; 128 shared_ptr<NiceMock<MockOffloadServiceUtils>> offload_service_utils_{ 129 new NiceMock<MockOffloadServiceUtils>()}; 130 shared_ptr<NiceMock<MockOffloadScanCallbackInterfaceImpl>> 131 offload_scan_callback_interface_{ 132 new NiceMock<MockOffloadScanCallbackInterfaceImpl>( 133 scanner_impl_.get())}; 134 std::shared_ptr<NiceMock<MockOffloadScanManager>> offload_scan_manager_{ 135 new NiceMock<MockOffloadScanManager>(offload_service_utils_, 136 offload_scan_callback_interface_)}; 137 ScanCapabilities scan_capabilities_; 138 WiphyFeatures wiphy_features_; 139 std::vector<ScanResult> dummy_scan_results_; 140}; 141 142TEST_F(ScannerTest, TestSingleScan) { 143 EXPECT_CALL(scan_utils_, Scan(_, _, _, _, _)).WillOnce(Return(true)); 144 bool success = false; 145 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 146 scan_capabilities_, wiphy_features_, 147 &client_interface_impl_, 148 &scan_utils_, offload_service_utils_)); 149 EXPECT_TRUE(scanner_impl_->scan(SingleScanSettings(), &success).isOk()); 150 EXPECT_TRUE(success); 151} 152 153TEST_F(ScannerTest, TestSingleScanFailure) { 154 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 155 scan_capabilities_, wiphy_features_, 156 &client_interface_impl_, 157 &scan_utils_, offload_service_utils_)); 158 EXPECT_CALL( 159 scan_utils_, 160 Scan(_, _, _, _, _)). 161 WillOnce(Invoke(bind( 162 ReturnErrorCodeForScanRequest, EBUSY, _1, _2, _3, _4, _5))); 163 164 bool success = false; 165 EXPECT_TRUE(scanner_impl_->scan(SingleScanSettings(), &success).isOk()); 166 EXPECT_FALSE(success); 167} 168 169TEST_F(ScannerTest, TestProcessAbortsOnScanReturningNoDeviceError) { 170 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 171 scan_capabilities_, wiphy_features_, 172 &client_interface_impl_, 173 &scan_utils_, offload_service_utils_)); 174 ON_CALL( 175 scan_utils_, 176 Scan(_, _, _, _, _)). 177 WillByDefault(Invoke(bind( 178 ReturnErrorCodeForScanRequest, ENODEV, _1, _2, _3, _4, _5))); 179 180 bool success_ignored; 181 EXPECT_DEATH(scanner_impl_->scan(SingleScanSettings(), &success_ignored), 182 "Driver is in a bad state*"); 183} 184 185TEST_F(ScannerTest, TestAbortScan) { 186 bool single_scan_success = false; 187 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 188 scan_capabilities_, wiphy_features_, 189 &client_interface_impl_, 190 &scan_utils_, offload_service_utils_)); 191 EXPECT_CALL(scan_utils_, Scan(_, _, _, _, _)).WillOnce(Return(true)); 192 EXPECT_TRUE( 193 scanner_impl_->scan(SingleScanSettings(), &single_scan_success).isOk()); 194 EXPECT_TRUE(single_scan_success); 195 196 EXPECT_CALL(scan_utils_, AbortScan(_)); 197 EXPECT_TRUE(scanner_impl_->abortScan().isOk()); 198} 199 200TEST_F(ScannerTest, TestAbortScanNotIssuedIfNoOngoingScan) { 201 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 202 scan_capabilities_, wiphy_features_, 203 &client_interface_impl_, 204 &scan_utils_, offload_service_utils_)); 205 EXPECT_CALL(scan_utils_, AbortScan(_)).Times(0); 206 EXPECT_TRUE(scanner_impl_->abortScan().isOk()); 207} 208 209TEST_F(ScannerTest, TestGetScanResults) { 210 vector<NativeScanResult> scan_results; 211 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 212 scan_capabilities_, wiphy_features_, 213 &client_interface_impl_, 214 &scan_utils_, offload_service_utils_)); 215 EXPECT_CALL(scan_utils_, GetScanResult(_, _)).WillOnce(Return(true)); 216 EXPECT_TRUE(scanner_impl_->getScanResults(&scan_results).isOk()); 217} 218 219TEST_F(ScannerTest, TestStartPnoScanViaNetlink) { 220 bool success = false; 221 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported()) 222 .Times(1) 223 .WillRepeatedly(Return(false)); 224 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 225 scan_capabilities_, wiphy_features_, 226 &client_interface_impl_, 227 &scan_utils_, offload_service_utils_)); 228 EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _)). 229 WillOnce(Return(true)); 230 EXPECT_TRUE(scanner_impl_->startPnoScan(PnoSettings(), &success).isOk()); 231 EXPECT_TRUE(success); 232} 233 234TEST_F(ScannerTest, TestStopPnoScanViaNetlink) { 235 bool success = false; 236 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported()) 237 .Times(1) 238 .WillRepeatedly(Return(false)); 239 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 240 scan_capabilities_, wiphy_features_, 241 &client_interface_impl_, 242 &scan_utils_, offload_service_utils_)); 243 // StopScheduledScan() will be called no matter if there is an ongoing 244 // scheduled scan or not. This is for making the system more robust. 245 EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true)); 246 EXPECT_TRUE(scanner_impl_->stopPnoScan(&success).isOk()); 247 EXPECT_TRUE(success); 248} 249 250TEST_F(ScannerTest, TestStartScanOverOffload) { 251 bool success = false; 252 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported()) 253 .Times(1) 254 .WillRepeatedly(Return(true)); 255 EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _)) 256 .Times(1) 257 .WillRepeatedly(Return(true)); 258 EXPECT_CALL(*offload_scan_manager_, stopScan(_)) 259 .Times(1) 260 .WillRepeatedly(Return(true)); 261 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 262 scan_capabilities_, wiphy_features_, 263 &client_interface_impl_, 264 &scan_utils_, offload_service_utils_)); 265 scanner_impl_->startPnoScan(PnoSettings(), &success); 266 EXPECT_TRUE(success); 267 scanner_impl_->stopPnoScan(&success); 268 EXPECT_TRUE(success); 269} 270 271TEST_F(ScannerTest, TestStartScanOverNetlinkFallback) { 272 bool success = false; 273 ON_CALL(*offload_service_utils_, IsOffloadScanSupported()) 274 .WillByDefault(Return(true)); 275 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 276 scan_capabilities_, wiphy_features_, 277 &client_interface_impl_, 278 &scan_utils_, offload_service_utils_)); 279 EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _)) 280 .WillOnce(Return(false)); 281 EXPECT_CALL(*offload_scan_manager_, stopScan(_)).Times(0); 282 EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _)) 283 .WillOnce(Return(true)); 284 EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true)); 285 EXPECT_TRUE(scanner_impl_->startPnoScan(PnoSettings(), &success).isOk()); 286 EXPECT_TRUE(success == true); 287 scanner_impl_->stopPnoScan(&success); 288 EXPECT_TRUE(success); 289} 290 291TEST_F(ScannerTest, TestAsyncErrorOverOffload) { 292 bool success = false; 293 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported()) 294 .Times(1) 295 .WillRepeatedly(Return(true)); 296 EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _)) 297 .Times(1) 298 .WillRepeatedly(Return(true)); 299 EXPECT_CALL(*offload_scan_manager_, stopScan(_)) 300 .Times(1) 301 .WillRepeatedly(Return(true)); 302 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 303 scan_capabilities_, wiphy_features_, 304 &client_interface_impl_, 305 &scan_utils_, offload_service_utils_)); 306 EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _)) 307 .WillOnce(Return(true)); 308 EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true)); 309 scanner_impl_->startPnoScan(PnoSettings(), &success); 310 EXPECT_TRUE(success); 311 scanner_impl_->OnOffloadError( 312 OffloadScanCallbackInterface::AsyncErrorReason::REMOTE_FAILURE); 313 scanner_impl_->stopPnoScan(&success); 314 EXPECT_TRUE(success); 315} 316 317TEST_F(ScannerTest, TestGetScanResultsFromOffload) { 318 bool success = false; 319 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported()) 320 .Times(1) 321 .WillRepeatedly(Return(true)); 322 EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _)) 323 .Times(1) 324 .WillRepeatedly(Return(true)); 325 EXPECT_CALL(*offload_scan_manager_, getScanResults(_)) 326 .Times(1) 327 .WillOnce( 328 Invoke(bind(ReturnOffloadScanResults, _1, dummy_scan_results_))); 329 EXPECT_CALL(*offload_scan_manager_, stopScan(_)) 330 .Times(1) 331 .WillRepeatedly(Return(true)); 332 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 333 scan_capabilities_, wiphy_features_, 334 &client_interface_impl_, 335 &scan_utils_, offload_service_utils_)); 336 scanner_impl_->startPnoScan(PnoSettings(), &success); 337 EXPECT_TRUE(success); 338 scanner_impl_->OnOffloadScanResult(); 339 std::vector<NativeScanResult> scan_results; 340 EXPECT_TRUE(scanner_impl_->getPnoScanResults(&scan_results).isOk()); 341 EXPECT_FALSE(scan_results.empty()); 342 scanner_impl_->stopPnoScan(&success); 343 EXPECT_TRUE(success); 344} 345 346TEST_F(ScannerTest, TestGetScanResultsWhenOffloadFails) { 347 bool success = false; 348 EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported()) 349 .Times(1) 350 .WillRepeatedly(Return(true)); 351 EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _)) 352 .Times(1) 353 .WillRepeatedly(Return(true)); 354 EXPECT_CALL(*offload_scan_manager_, stopScan(_)) 355 .Times(1) 356 .WillRepeatedly(Return(true)); 357 EXPECT_CALL(*offload_scan_manager_, getScanResults(_)).Times(0); 358 EXPECT_CALL(scan_utils_, GetScanResult(_, _)) 359 .Times(1) 360 .WillOnce( 361 Invoke(bind(ReturnNetlinkScanResults, _1, _2, dummy_scan_results_))); 362 scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex, 363 scan_capabilities_, wiphy_features_, 364 &client_interface_impl_, 365 &scan_utils_, offload_service_utils_)); 366 EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _)) 367 .WillOnce(Return(true)); 368 EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true)); 369 EXPECT_TRUE(scanner_impl_->startPnoScan(PnoSettings(), &success).isOk()); 370 EXPECT_TRUE(success); 371 scanner_impl_->OnOffloadError( 372 OffloadScanCallbackInterface::AsyncErrorReason::REMOTE_FAILURE); 373 std::vector<NativeScanResult> scan_results; 374 EXPECT_TRUE(scanner_impl_->getPnoScanResults(&scan_results).isOk()); 375 EXPECT_FALSE(scan_results.empty()); 376 scanner_impl_->stopPnoScan(&success); 377 EXPECT_TRUE(success); 378} 379 380TEST_F(ScannerTest, TestGenerateScanPlansIfDeviceSupports) { 381 ScanCapabilities scan_capabilities_scan_plan_supported( 382 0 /* max_num_scan_ssids */, 383 0 /* max_num_sched_scan_ssids */, 384 0 /* max_match_sets */, 385 // Parameters above are not related to this test. 386 2 /* 1 plan for finite repeated scan and 1 plan for ininfite scan loop */, 387 kFakeScanIntervalMs * PnoSettings::kSlowScanIntervalMultiplier / 1000, 388 PnoSettings::kFastScanIterations); 389 ScannerImpl scanner( 390 kFakeInterfaceIndex, 391 scan_capabilities_scan_plan_supported, wiphy_features_, 392 &client_interface_impl_, 393 &scan_utils_, offload_service_utils_); 394 395 PnoSettings pno_settings; 396 pno_settings.interval_ms_ = kFakeScanIntervalMs; 397 398 SchedScanIntervalSetting interval_setting; 399 EXPECT_CALL( 400 scan_utils_, 401 StartScheduledScan(_, _, _, _, _, _, _, _)). 402 WillOnce(Invoke(bind( 403 CaptureSchedScanIntervalSetting, 404 _1, _2, _3, _4, _5, _6, _7, _8, &interval_setting))); 405 406 bool success_ignored = 0; 407 EXPECT_TRUE(scanner.startPnoScan(pno_settings, &success_ignored).isOk()); 408 /* 1 plan for finite repeated scan */ 409 EXPECT_EQ(1U, interval_setting.plans.size()); 410 EXPECT_EQ(kFakeScanIntervalMs * PnoSettings::kSlowScanIntervalMultiplier, 411 interval_setting.final_interval_ms); 412} 413 414TEST_F(ScannerTest, TestGenerateSingleIntervalIfDeviceDoesNotSupportScanPlan) { 415 ScanCapabilities scan_capabilities_no_scan_plan_support( 416 0 /* max_num_scan_ssids */, 417 0 /* max_num_sched_scan_ssids */, 418 0 /* max_match_sets */, 419 // Parameters above are not related to this test. 420 0 /* max_num_scan_plans */, 421 0 /* max_scan_plan_interval */, 422 0 /* max_scan_plan_iterations */); 423 ScannerImpl scanner( 424 kFakeInterfaceIndex, 425 scan_capabilities_no_scan_plan_support, wiphy_features_, 426 &client_interface_impl_, 427 &scan_utils_, offload_service_utils_); 428 PnoSettings pno_settings; 429 pno_settings.interval_ms_ = kFakeScanIntervalMs; 430 431 SchedScanIntervalSetting interval_setting; 432 EXPECT_CALL( 433 scan_utils_, 434 StartScheduledScan(_, _, _, _, _, _, _, _)). 435 WillOnce(Invoke(bind( 436 CaptureSchedScanIntervalSetting, 437 _1, _2, _3, _4, _5, _6, _7, _8, &interval_setting))); 438 439 bool success_ignored = 0; 440 EXPECT_TRUE(scanner.startPnoScan(pno_settings, &success_ignored).isOk()); 441 442 EXPECT_EQ(0U, interval_setting.plans.size()); 443 EXPECT_EQ(kFakeScanIntervalMs, interval_setting.final_interval_ms); 444} 445 446} // namespace wificond 447} // namespace android 448