tests/offload_scan_manager_test.cpp

   1 /*
   2  * Copyright (C) 2016, 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 <functional>
  18 #include <memory>
  19 #include <string>
  20 #include <vector>
  21
  22 #include <android/hardware/wifi/offload/1.0/IOffload.h>
  23 #include <gtest/gtest.h>
  24
  25 #include "wificond/tests/mock_offload.h"
  26 #include "wificond/tests/mock_offload_service_utils.h"
  27 #include "wificond/tests/offload_hal_test_constants.h"
  28 #include "wificond/tests/offload_test_utils.h"
  29
  30 #include "wificond/scanning/offload/offload_callback.h"
  31 #include "wificond/scanning/offload/offload_callback_handlers.h"
  32 #include "wificond/scanning/offload/offload_scan_manager.h"
  33 #include "wificond/scanning/scan_result.h"
  34
  35 using android::hardware::Return;
  36 using android::hardware::Void;
  37 using android::hardware::wifi::offload::V1_0::IOffload;
  38 using android::hardware::wifi::offload::V1_0::ScanResult;
  39 using android::hardware::wifi::offload::V1_0::OffloadStatus;
  40 using android::hardware::wifi::offload::V1_0::OffloadStatusCode;
  41 using android::hardware::wifi::offload::V1_0::ScanParam;
  42 using android::hardware::wifi::offload::V1_0::ScanFilter;
  43 using android::hardware::wifi::offload::V1_0::ScanStats;
  44 using android::sp;
  45 using com::android::server::wifi::wificond::NativeScanResult;
  46 using com::android::server::wifi::wificond::NativeScanStats;
  47 using testing::NiceMock;
  48 using testing::_;
  49 using testing::Invoke;
  50 using std::unique_ptr;
  51 using std::vector;
  52 using std::bind;
  53
  54 using namespace std::placeholders;
  55 using namespace android::wificond::offload_hal_test_constants;
  56
  57 namespace android {
  58 namespace wificond {
  59
  60 sp<OffloadCallback> CaptureCallback(OffloadCallbackHandlers* handler,
  61                                     sp<OffloadCallback>* offload_callback) {
  62   *offload_callback = sp<OffloadCallback>(new OffloadCallback(handler));
  63   return *offload_callback;
  64 }
  65
  66 OffloadDeathRecipient* CaptureDeathRecipient(
  67     OffloadDeathRecipientHandler handler,
  68     sp<OffloadDeathRecipient>* death_recipient_) {
  69   OffloadDeathRecipient* death_recipient = new OffloadDeathRecipient(handler);
  70   *death_recipient_ = sp<OffloadDeathRecipient>(death_recipient);
  71   return death_recipient;
  72 }
  73
  74 Return<void> HidlStatusReturn(android::wificond::StatusCallback cb,
  75                               OffloadStatus* status) {
  76   cb(*status);
  77   return Void();
  78 }
  79
  80 Return<void> ScanStatusReturn(android::wificond::OnScanStatsCallback cb,
  81                               OffloadStatus* status) {
  82   ScanStats stats;
  83   cb(*status, stats);
  84   return Void();
  85 }
  86
  87 class OffloadScanManagerTest : public ::testing::Test {
  88  protected:
  89   virtual void SetUp() {
  90     ON_CALL(*mock_offload_service_utils_, GetOffloadCallback(_))
  91         .WillByDefault(Invoke(bind(CaptureCallback, _1, &offload_callback_)));
  92     ON_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_))
  93         .WillByDefault(
  94             Invoke(bind(CaptureDeathRecipient, _1, &death_recipient_)));
  95     status = OffloadTestUtils::createOffloadStatus(OffloadStatusCode::OK);
  96     ON_CALL(*mock_offload_, configureScans(_, _, _))
  97         .WillByDefault(Invoke(bind(HidlStatusReturn, _3, &status)));
  98     ON_CALL(*mock_offload_, subscribeScanResults(_, _))
  99         .WillByDefault(Invoke(bind(HidlStatusReturn, _2, &status)));
 100     ON_CALL(*mock_offload_, getScanStats(_))
 101         .WillByDefault(Invoke(bind(ScanStatusReturn, _1, &status)));
 102   }
 103
 104   void TearDown() override {
 105     offload_callback_.clear();
 106     death_recipient_.clear();
 107   }
 108
 109   sp<NiceMock<MockOffload>> mock_offload_{new NiceMock<MockOffload>()};
 110   sp<OffloadCallback> offload_callback_;
 111   sp<OffloadDeathRecipient> death_recipient_;
 112   unique_ptr<NiceMock<MockOffloadServiceUtils>> mock_offload_service_utils_{
 113       new NiceMock<MockOffloadServiceUtils>()};
 114   unique_ptr<OffloadScanManager> offload_scan_manager_;
 115   OffloadStatus status;
 116   vector<vector<uint8_t>> scan_ssids{kSsid1, kSsid2};
 117   vector<vector<uint8_t>> match_ssids{kSsid1, kSsid2};
 118   vector<uint8_t> security_flags{kNetworkFlags, kNetworkFlags};
 119   vector<uint32_t> frequencies{kFrequency1, kFrequency2};
 120   uint64_t cookie_ = reinterpret_cast<uint64_t>(mock_offload_.get());
 121 };
 122
 123 /**
 124  * Testing OffloadScanManager for binder death with registered cookie
 125  */
 126 TEST_F(OffloadScanManagerTest, BinderDeathRegisteredCookieAndService) {
 127   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 128   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_));
 129   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_));
 130   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 131       .WillByDefault(testing::Return(mock_offload_));
 132   offload_scan_manager_.reset(new OffloadScanManager(
 133       mock_offload_service_utils_.get(),
 134       [](vector<NativeScanResult> scanResult) -> void {}));
 135   death_recipient_->serviceDied(cookie_, mock_offload_);
 136   EXPECT_EQ(OffloadScanManager::kNoService,
 137             offload_scan_manager_->getOffloadStatus());
 138 }
 139
 140 /**
 141  * Testing OffloadScanManager for binder death with invalid cookie
 142  */
 143 TEST_F(OffloadScanManagerTest, BinderDeathUnregisteredCookie) {
 144   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 145   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_));
 146   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 147       .WillByDefault(testing::Return(mock_offload_));
 148   offload_scan_manager_.reset(new OffloadScanManager(
 149       mock_offload_service_utils_.get(),
 150       [](vector<NativeScanResult> scanResult) -> void {}));
 151   death_recipient_->serviceDied(kDeathCode, mock_offload_);
 152   EXPECT_FALSE(OffloadScanManager::kNoService ==
 153                offload_scan_manager_->getOffloadStatus());
 154 }
 155
 156 /**
 157  * Testing OffloadScanManager with OffloadServiceUtils null argument
 158  */
 159 TEST_F(OffloadScanManagerTest, ServiceUtilsNotAvailableTest) {
 160   offload_scan_manager_.reset(new OffloadScanManager(nullptr, nullptr));
 161   EXPECT_EQ(OffloadScanManager::kNoService,
 162             offload_scan_manager_->getOffloadStatus());
 163 }
 164
 165 /**
 166  * Testing OffloadScanManager with no handle on Offloal HAL service
 167  * and no registered handler for Offload Scan results
 168  */
 169 TEST_F(OffloadScanManagerTest, ServiceNotAvailableTest) {
 170   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 171   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 172       .WillByDefault(testing::Return(nullptr));
 173   offload_scan_manager_.reset(new OffloadScanManager(
 174       mock_offload_service_utils_.get(),
 175       [](vector<NativeScanResult> scanResult) -> void {}));
 176   EXPECT_EQ(OffloadScanManager::kNoService,
 177             offload_scan_manager_->getOffloadStatus());
 178 }
 179
 180 /**
 181  * Testing OffloadScanManager when service is available and valid handler
 182  * registered for Offload Scan results
 183  */
 184 TEST_F(OffloadScanManagerTest, ServiceAvailableTest) {
 185   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 186   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_));
 187   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_));
 188   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 189       .WillByDefault(testing::Return(mock_offload_));
 190   offload_scan_manager_.reset(new OffloadScanManager(
 191       mock_offload_service_utils_.get(),
 192       [](vector<NativeScanResult> scanResult) -> void {}));
 193   EXPECT_EQ(OffloadScanManager::kNoError,
 194             offload_scan_manager_->getOffloadStatus());
 195 }
 196
 197 /**
 198  * Testing OffloadScanManager when service is available and valid handler
 199  * is registered, test to ensure that registered handler is invoked when
 200  * scan results are available
 201  */
 202 TEST_F(OffloadScanManagerTest, CallbackInvokedTest) {
 203   bool callback_invoked = false;
 204   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 205   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_));
 206   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_));
 207   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 208       .WillByDefault(testing::Return(mock_offload_));
 209   offload_scan_manager_.reset(new OffloadScanManager(
 210       mock_offload_service_utils_.get(),
 211       [&callback_invoked](vector<NativeScanResult> scanResult) -> void {
 212         callback_invoked = true;
 213       }));
 214   vector<ScanResult> dummy_scan_results_ =
 215       OffloadTestUtils::createOffloadScanResults();
 216   offload_callback_->onScanResult(dummy_scan_results_);
 217   EXPECT_EQ(true, callback_invoked);
 218 }
 219
 220 /**
 221  * Testing OffloadScanManager when service is available and valid handler
 222  * is registered, ensure that error callback is invoked
 223  */
 224 TEST_F(OffloadScanManagerTest, ErrorCallbackInvokedTest) {
 225   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 226   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_));
 227   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_));
 228   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 229       .WillByDefault(testing::Return(mock_offload_));
 230   offload_scan_manager_.reset(new OffloadScanManager(
 231       mock_offload_service_utils_.get(),
 232       [](vector<NativeScanResult> scanResult) -> void {}));
 233   OffloadStatus status =
 234       OffloadTestUtils::createOffloadStatus(OffloadStatusCode::ERROR);
 235   offload_callback_->onError(status);
 236   EXPECT_EQ(offload_scan_manager_->getOffloadStatus(),
 237             OffloadScanManager::kError);
 238 }
 239
 240 /**
 241  * Testing OffloadScanManager for subscribing to the scan results from
 242  * Offload HAL when service is running without errors
 243  */
 244 TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsOk) {
 245   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 246   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_));
 247   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_));
 248   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 249       .WillByDefault(testing::Return(mock_offload_));
 250   offload_scan_manager_.reset(new OffloadScanManager(
 251       mock_offload_service_utils_.get(),
 252       [](vector<NativeScanResult> scanResult) -> void {}));
 253   EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _));
 254   EXPECT_CALL(*mock_offload_, configureScans(_, _, _));
 255   OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
 256   bool result = offload_scan_manager_->startScan(
 257       kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids,
 258       security_flags, frequencies, &reason_code);
 259   EXPECT_EQ(result, true);
 260 }
 261
 262 /**
 263  * Testing OffloadScanManager for subscribing to the scan results from
 264  * Offload HAL when service is not available
 265  */
 266 TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsNotAvailable) {
 267   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 268   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 269       .WillByDefault(testing::Return(nullptr));
 270   offload_scan_manager_.reset(new OffloadScanManager(
 271       mock_offload_service_utils_.get(),
 272       [](vector<NativeScanResult> scanResult) -> void {}));
 273   OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
 274   bool result = offload_scan_manager_->startScan(
 275       kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids,
 276       security_flags, frequencies, &reason_code);
 277   EXPECT_EQ(result, false);
 278   EXPECT_EQ(reason_code, OffloadScanManager::kNotAvailable);
 279 }
 280
 281 /**
 282  * Testing OffloadScanManager for subscribing to the scan results from
 283  * Offload HAL when service is not working correctly
 284  */
 285 TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsNotConnected) {
 286   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 287   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_));
 288   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_));
 289   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 290       .WillByDefault(testing::Return(mock_offload_));
 291   offload_scan_manager_.reset(new OffloadScanManager(
 292       mock_offload_service_utils_.get(),
 293       [](vector<NativeScanResult> scanResult) -> void {}));
 294   OffloadStatus status =
 295       OffloadTestUtils::createOffloadStatus(OffloadStatusCode::NO_CONNECTION);
 296   offload_callback_->onError(status);
 297   OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
 298   bool result = offload_scan_manager_->startScan(
 299       kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids,
 300       security_flags, frequencies, &reason_code);
 301   EXPECT_EQ(result, false);
 302   EXPECT_EQ(reason_code, OffloadScanManager::kNotAvailable);
 303 }
 304
 305 /**
 306  * Testing OffloadScanManager for subscribing to the scan results from
 307  * Offload HAL twice when service is okay
 308  */
 309 TEST_F(OffloadScanManagerTest, StartScanTwiceTestWhenServiceIsOk) {
 310   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 311   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_));
 312   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_));
 313   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 314       .WillByDefault(testing::Return(mock_offload_));
 315   offload_scan_manager_.reset(new OffloadScanManager(
 316       mock_offload_service_utils_.get(),
 317       [](vector<NativeScanResult> scanResult) -> void {}));
 318   EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)).Times(1);
 319   EXPECT_CALL(*mock_offload_, configureScans(_, _, _)).Times(2);
 320   OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
 321   bool result = offload_scan_manager_->startScan(
 322       kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids,
 323       security_flags, frequencies, &reason_code);
 324   EXPECT_EQ(result, true);
 325   result = offload_scan_manager_->startScan(
 326       kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids,
 327       security_flags, frequencies, &reason_code);
 328   EXPECT_EQ(result, true);
 329 }
 330
 331 /**
 332  * Testing OffloadScanManager for unsubscribing to the scan results from
 333  * Offload HAL when service is ok
 334  */
 335 TEST_F(OffloadScanManagerTest, StopScanTestWhenServiceIsOk) {
 336   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 337   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_));
 338   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_));
 339   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 340       .WillByDefault(testing::Return(mock_offload_));
 341   offload_scan_manager_.reset(new OffloadScanManager(
 342       mock_offload_service_utils_.get(),
 343       [](vector<NativeScanResult> scanResult) -> void {}));
 344   EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _));
 345   EXPECT_CALL(*mock_offload_, configureScans(_, _, _));
 346   EXPECT_CALL(*mock_offload_, unsubscribeScanResults());
 347   OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
 348   bool result = offload_scan_manager_->startScan(
 349       kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids,
 350       security_flags, frequencies, &reason_code);
 351   EXPECT_EQ(result, true);
 352   result = offload_scan_manager_->stopScan(&reason_code);
 353   EXPECT_EQ(result, true);
 354 }
 355
 356 /**
 357  * Testing OffloadScanManager for unsubscribing to the scan results from
 358  * Offload HAL without first subscribing
 359  */
 360 TEST_F(OffloadScanManagerTest, StopScanTestWithoutStartWhenServiceIsOk) {
 361   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 362   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_));
 363   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_));
 364   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 365       .WillByDefault(testing::Return(mock_offload_));
 366   offload_scan_manager_.reset(new OffloadScanManager(
 367       mock_offload_service_utils_.get(),
 368       [](vector<NativeScanResult> scanResult) -> void {}));
 369   OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
 370   bool result = offload_scan_manager_->stopScan(&reason_code);
 371   EXPECT_EQ(result, false);
 372   EXPECT_EQ(reason_code, OffloadScanManager::kNotSubscribed);
 373 }
 374
 375 /**
 376  * Testing OffloadScanManager for unsubscribing to the scan results from
 377  * Offload HAL without first subscribing when service is not working correctly
 378  */
 379 TEST_F(OffloadScanManagerTest, StopScanTestWhenServiceIsNotConnectedAnymore) {
 380   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 381   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_));
 382   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 383       .WillByDefault(testing::Return(mock_offload_));
 384   offload_scan_manager_.reset(new OffloadScanManager(
 385       mock_offload_service_utils_.get(),
 386       [](vector<NativeScanResult> scanResult) -> void {}));
 387   EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _));
 388   EXPECT_CALL(*mock_offload_, configureScans(_, _, _));
 389   EXPECT_CALL(*mock_offload_, unsubscribeScanResults());
 390   OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
 391   bool result = offload_scan_manager_->startScan(
 392       kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids,
 393       security_flags, frequencies, &reason_code);
 394   EXPECT_EQ(result, true);
 395   OffloadStatus status =
 396       OffloadTestUtils::createOffloadStatus(OffloadStatusCode::NO_CONNECTION);
 397   offload_callback_->onError(status);
 398   result = offload_scan_manager_->stopScan(&reason_code);
 399   EXPECT_EQ(result, true);
 400 }
 401
 402 /**
 403  * Testing OffloadScanManager for getting scan statistics when the
 404  * Offload HAL service is running without errors
 405  */
 406 TEST_F(OffloadScanManagerTest, getScanStatsTestWhenServiceIsOk) {
 407   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 408   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_));
 409   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_));
 410   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 411       .WillByDefault(testing::Return(mock_offload_));
 412   offload_scan_manager_.reset(new OffloadScanManager(
 413       mock_offload_service_utils_.get(),
 414       [](vector<NativeScanResult> scanResult) -> void {}));
 415   EXPECT_CALL(*mock_offload_, getScanStats(_));
 416   NativeScanStats stats;
 417   bool result = offload_scan_manager_->getScanStats(&stats);
 418   EXPECT_EQ(result, true);
 419 }
 420
 421 /**
 422  * Testing OffloadScanManager for getting scan statistics when the
 423  * Offload HAL service is not connected
 424  */
 425 TEST_F(OffloadScanManagerTest, getScanStatsTestWhenServiceIsNotOk) {
 426   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 427   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_));
 428   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_));
 429   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 430       .WillByDefault(testing::Return(mock_offload_));
 431   offload_scan_manager_.reset(new OffloadScanManager(
 432       mock_offload_service_utils_.get(),
 433       [](vector<NativeScanResult> scanResult) -> void {}));
 434   OffloadStatus status =
 435       OffloadTestUtils::createOffloadStatus(OffloadStatusCode::NO_CONNECTION);
 436   offload_callback_->onError(status);
 437   EXPECT_CALL(*mock_offload_, getScanStats(_)).Times(0);
 438   NativeScanStats stats;
 439   bool result = offload_scan_manager_->getScanStats(&stats);
 440   EXPECT_EQ(result, false);
 441 }
 442
 443 /**
 444  * Testing OffloadScanManager for subscribing to the scan results from
 445  * Offload HAL when service is running without errors, operation failure
 446  */
 447 TEST_F(OffloadScanManagerTest, StartScanFailedTest) {
 448   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 449   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_));
 450   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_));
 451   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 452       .WillByDefault(testing::Return(mock_offload_));
 453   offload_scan_manager_.reset(new OffloadScanManager(
 454       mock_offload_service_utils_.get(),
 455       [](vector<NativeScanResult> scanResult) -> void {}));
 456   EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)).Times(0);
 457   EXPECT_CALL(*mock_offload_, configureScans(_, _, _)).Times(1);
 458   status = OffloadTestUtils::createOffloadStatus(OffloadStatusCode::ERROR);
 459   OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
 460   bool result = offload_scan_manager_->startScan(
 461       kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids,
 462       security_flags, frequencies, &reason_code);
 463   EXPECT_EQ(result, false);
 464   EXPECT_EQ(reason_code, OffloadScanManager::kOperationFailed);
 465 }
 466
 467 /**
 468  * Testing OffloadScanManager for getting scan statistics when the
 469  * Offload HAL service is running without errors, getting scan stats failure
 470  */
 471 TEST_F(OffloadScanManagerTest, getScanStatsFailedTest) {
 472   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 473   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_));
 474   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_));
 475   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 476       .WillByDefault(testing::Return(mock_offload_));
 477   offload_scan_manager_.reset(new OffloadScanManager(
 478       mock_offload_service_utils_.get(),
 479       [](vector<NativeScanResult> scanResult) -> void {}));
 480   status = OffloadTestUtils::createOffloadStatus(OffloadStatusCode::TIMEOUT);
 481   EXPECT_CALL(*mock_offload_, getScanStats(_));
 482   NativeScanStats stats;
 483   bool result = offload_scan_manager_->getScanStats(&stats);
 484   EXPECT_EQ(result, false);
 485 }
 486
 487 }  // namespace wificond
 488 }  // namespace android