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