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