ScannerImpl: Add unit tests for scheduled scans

This patch adds unit tests for scheduled scans.
In order to do that, this also moves the isOffloadScanSupprted()
out of OffloadScanManager to OffloadServiceUtils. By injecting
MockOffloadServiceUtils to ScannerImpl, we can test either offload
supported or not supported cases.

Bug: 33452931
Test: compile, unit tests
Test: manual test that offload scan is not enabled by mistake.
This is done by checking manually inserted logs.

Change-Id: I6c78df78605321013676e5f4578026f21d953e3b

diff --git a/client_interface_impl.cpp b/client_interface_impl.cpp
index 405d1fd..58edbbb 100644 (file)
--- a/client_interface_impl.cpp
+++ b/client_interface_impl.cpp
@@ -24,6 +24,7 @@
 #include "wificond/client_interface_binder.h"
 #include "wificond/net/mlme_event.h"
 #include "wificond/net/netlink_utils.h"
+#include "wificond/scanning/offload/offload_service_utils.h"
 #include "wificond/scanning/scan_result.h"
 #include "wificond/scanning/scan_utils.h"
 #include "wificond/scanning/scanner_impl.h"
@@ -116,6 +117,7 @@ ClientInterfaceImpl::ClientInterfaceImpl(
       supplicant_manager_(supplicant_manager),
       netlink_utils_(netlink_utils),
       scan_utils_(scan_utils),
+      offload_service_utils_(new OffloadServiceUtils()),
       mlme_event_handler_(new MlmeEventHandlerImpl(this)),
       binder_(new ClientInterfaceBinder(this)),
       is_associated_(false) {
@@ -136,7 +138,8 @@ ClientInterfaceImpl::ClientInterfaceImpl(
                              wiphy_features_,
                              this,
                              netlink_utils_,
-                             scan_utils_);
+                             scan_utils_,
+                             offload_service_utils_);
 }
 
 ClientInterfaceImpl::~ClientInterfaceImpl() {

diff --git a/client_interface_impl.h b/client_interface_impl.h
index 96e6fd9..6ce0547 100644 (file)
--- a/client_interface_impl.h
+++ b/client_interface_impl.h
@@ -27,6 +27,7 @@
 #include "android/net/wifi/IClientInterface.h"
 #include "wificond/net/mlme_event_handler.h"
 #include "wificond/net/netlink_utils.h"
+#include "wificond/scanning/offload/offload_service_utils.h"
 #include "wificond/scanning/scanner_impl.h"
 
 namespace android {
@@ -96,6 +97,7 @@ class ClientInterfaceImpl {
   android::wifi_system::SupplicantManager* const supplicant_manager_;
   NetlinkUtils* const netlink_utils_;
   ScanUtils* const scan_utils_;
+  const std::shared_ptr<OffloadServiceUtils> offload_service_utils_;
   const std::unique_ptr<MlmeEventHandlerImpl> mlme_event_handler_;
   const android::sp<ClientInterfaceBinder> binder_;
   android::sp<ScannerImpl> scanner_;

diff --git a/scanning/offload/offload_scan_manager.cpp b/scanning/offload/offload_scan_manager.cpp
index 04a425c..5e3d90d 100644 (file)
--- a/scanning/offload/offload_scan_manager.cpp
+++ b/scanning/offload/offload_scan_manager.cpp
@@ -38,8 +38,10 @@ using android::wificond::OffloadCallback;
 using android::wificond::OnNativeScanResultsReadyHandler;
 using ::com::android::server::wifi::wificond::NativeScanResult;
 using ::com::android::server::wifi::wificond::NativeScanStats;
-using namespace std::placeholders;
 using std::vector;
+using std::weak_ptr;
+
+using namespace std::placeholders;
 
 namespace {
 const uint32_t kSubscriptionDelayMs = 5000;
@@ -67,7 +69,7 @@ void OffloadCallbackHandlersImpl::OnErrorHandler(const OffloadStatus& status) {
   }
 }
 
-OffloadScanManager::OffloadScanManager(OffloadServiceUtils* utils,
+OffloadScanManager::OffloadScanManager(weak_ptr<OffloadServiceUtils> utils,
                                        OnNativeScanResultsReadyHandler handler)
     : wifi_offload_hal_(nullptr),
       wifi_offload_callback_(nullptr),
@@ -75,21 +77,18 @@ OffloadScanManager::OffloadScanManager(OffloadServiceUtils* utils,
       subscription_enabled_(false),
       offload_callback_handlers_(new OffloadCallbackHandlersImpl(this)),
       scan_result_handler_(handler) {
-  if (utils == nullptr) {
-    LOG(ERROR) << "Invalid arguments for Offload ScanManager";
-    return;
-  }
+  auto offload_scan_utils = utils.lock();
   if (scan_result_handler_ == nullptr) {
     LOG(ERROR) << "Invalid Offload scan result handler";
     return;
   }
-  wifi_offload_hal_ = utils->GetOffloadService();
+  wifi_offload_hal_ = offload_scan_utils->GetOffloadService();
   if (wifi_offload_hal_ == nullptr) {
     LOG(ERROR) << "No Offload Service available";
     return;
   }
 
-  death_recipient_ = utils->GetOffloadDeathRecipient(
+  death_recipient_ = offload_scan_utils->GetOffloadDeathRecipient(
       std::bind(&OffloadScanManager::OnObjectDeath, this, _1));
   uint64_t cookie = reinterpret_cast<uint64_t>(wifi_offload_hal_.get());
   auto link_to_death_status =
@@ -101,7 +100,7 @@ OffloadScanManager::OffloadScanManager(OffloadServiceUtils* utils,
   }
 
   wifi_offload_callback_ =
-      utils->GetOffloadCallback(offload_callback_handlers_.get());
+      offload_scan_utils->GetOffloadCallback(offload_callback_handlers_.get());
   if (wifi_offload_callback_ == nullptr) {
     LOG(ERROR) << "Invalid Offload callback object";
     return;
@@ -215,15 +214,6 @@ OffloadScanManager::StatusCode OffloadScanManager::getOffloadStatus() const {
   return offload_status_;
 }
 
-bool OffloadScanManager::isOffloadScanSupported() const {
-  bool result = false;
-#ifdef WIFI_OFFLOAD_SCANS
-  LOG(VERBOSE) << "Offload HAL supported";
-  result = true;
-#endif
-  return result;
-}
-
 bool OffloadScanManager::getScanStats(NativeScanStats* native_scan_stats) {
   if (getOffloadStatus() != OffloadScanManager::kNoError) {
     LOG(WARNING) << "Unable to get scan stats due to Wifi Offload HAL error";

diff --git a/scanning/offload/offload_scan_manager.h b/scanning/offload/offload_scan_manager.h
index 38b0c2d..e2c2b0c 100644 (file)
--- a/scanning/offload/offload_scan_manager.h
+++ b/scanning/offload/offload_scan_manager.h
@@ -94,7 +94,7 @@ class OffloadScanManager {
     kTransactionFailed,
   };
 
-  explicit OffloadScanManager(OffloadServiceUtils* utils,
+  explicit OffloadScanManager(std::weak_ptr<OffloadServiceUtils> utils,
                               OnNativeScanResultsReadyHandler handler);
   virtual ~OffloadScanManager();
   /* Request start of offload scans with scan parameters and scan filter
@@ -118,8 +118,6 @@ class OffloadScanManager {
       ::com::android::server::wifi::wificond::NativeScanStats* /* scanStats */);
   /* Otain status of the Offload HAL service */
   StatusCode getOffloadStatus() const;
-  /* Check if Offload service is supported on this device */
-  bool isOffloadScanSupported() const;
 
  private:
   void ReportScanResults(

diff --git a/scanning/offload/offload_service_utils.cpp b/scanning/offload/offload_service_utils.cpp
index 141530e..2a14a32 100644 (file)
--- a/scanning/offload/offload_service_utils.cpp
+++ b/scanning/offload/offload_service_utils.cpp
@@ -35,6 +35,15 @@ OffloadDeathRecipient* OffloadServiceUtils::GetOffloadDeathRecipient(
   return new OffloadDeathRecipient(handler);
 }
 
+bool OffloadServiceUtils::IsOffloadScanSupported() const {
+  bool result = false;
+#ifdef WIFI_OFFLOAD_SCANS
+  LOG(VERBOSE) << "Offload HAL supported";
+  result = true;
+#endif
+  return result;
+}
+
 OffloadDeathRecipient::OffloadDeathRecipient(
     OffloadDeathRecipientHandler handler)
     : handler_(handler) {}

diff --git a/scanning/offload/offload_service_utils.h b/scanning/offload/offload_service_utils.h
index 3080d55..cff5575 100644 (file)
--- a/scanning/offload/offload_service_utils.h
+++ b/scanning/offload/offload_service_utils.h
@@ -46,6 +46,8 @@ class OffloadServiceUtils {
   virtual ~OffloadServiceUtils() = default;
   virtual android::sp<android::hardware::wifi::offload::V1_0::IOffload>
       GetOffloadService();
+  // Check if Offload scan is supported on this device.
+  virtual bool IsOffloadScanSupported() const;
   virtual android::sp<OffloadCallback> GetOffloadCallback(
       OffloadCallbackHandlers* handlers);
   virtual OffloadDeathRecipient* GetOffloadDeathRecipient(

diff --git a/scanning/scanner_impl.cpp b/scanning/scanner_impl.cpp
index 7beef34..a1ea261 100644 (file)
--- a/scanning/scanner_impl.cpp
+++ b/scanning/scanner_impl.cpp
@@ -37,6 +37,7 @@ using com::android::server::wifi::wificond::SingleScanSettings;
 
 using std::string;
 using std::vector;
+using std::weak_ptr;
 
 using namespace std::placeholders;
 
@@ -49,7 +50,8 @@ ScannerImpl::ScannerImpl(uint32_t wiphy_index,
                          const WiphyFeatures& wiphy_features,
                          ClientInterfaceImpl* client_interface,
                          NetlinkUtils* netlink_utils,
-                         ScanUtils* scan_utils)
+                         ScanUtils* scan_utils,
+                         weak_ptr<OffloadServiceUtils> offload_service_utils)
     : valid_(true),
       scan_started_(false),
       pno_scan_started_(false),
@@ -77,10 +79,11 @@ ScannerImpl::ScannerImpl(uint32_t wiphy_index,
                 this,
                 _1, _2));
   offload_scan_manager_.reset(
-      new OffloadScanManager(new OffloadServiceUtils(),
+      new OffloadScanManager(
+          offload_service_utils,
           std::bind(&ScannerImpl::OnOffloadScanResult,
               this, _1)));
-  offload_scan_supported_ = offload_scan_manager_->isOffloadScanSupported();
+  offload_scan_supported_ = offload_service_utils.lock()->IsOffloadScanSupported();
 }
 
 ScannerImpl::~ScannerImpl() {

diff --git a/scanning/scanner_impl.h b/scanning/scanner_impl.h
index ade8f43..fe66f17 100644 (file)
--- a/scanning/scanner_impl.h
+++ b/scanning/scanner_impl.h
@@ -30,6 +30,7 @@ namespace android {
 namespace wificond {
 
 class ClientInterfaceImpl;
+class OffloadServiceUtils;
 class ScanUtils;
 
 class ScannerImpl : public android::net::wifi::BnWifiScannerImpl {
@@ -40,7 +41,8 @@ class ScannerImpl : public android::net::wifi::BnWifiScannerImpl {
               const WiphyFeatures& wiphy_features,
               ClientInterfaceImpl* client_interface,
               NetlinkUtils* netlink_utils,
-              ScanUtils* scan_utils);
+              ScanUtils* scan_utils,
+              std::weak_ptr<OffloadServiceUtils> offload_service_utils);
   ~ScannerImpl();
   // Returns a vector of available frequencies for 2.4GHz channels.
   ::android::binder::Status getAvailable2gChannels(

diff --git a/tests/mock_offload_service_utils.h b/tests/mock_offload_service_utils.h
index 0b5a2a2..fd9fd34 100644 (file)
--- a/tests/mock_offload_service_utils.h
+++ b/tests/mock_offload_service_utils.h
@@ -32,7 +32,7 @@ class MockOffloadServiceUtils : public OffloadServiceUtils {
  public:
   MockOffloadServiceUtils();
   ~MockOffloadServiceUtils() override = default;
-
+  MOCK_CONST_METHOD0(IsOffloadScanSupported, bool());
   MOCK_METHOD0(GetOffloadService,
                sp<android::hardware::wifi::offload::V1_0::IOffload>());
   MOCK_METHOD1(GetOffloadCallback,

diff --git a/tests/mock_scan_utils.h b/tests/mock_scan_utils.h
index fbd1acd..f3e1777 100644 (file)
--- a/tests/mock_scan_utils.h
+++ b/tests/mock_scan_utils.h
@@ -29,8 +29,14 @@ class MockScanUtils : public ScanUtils {
   MockScanUtils(NetlinkManager* netlink_manager);
   ~MockScanUtils() override = default;
 
+  MOCK_METHOD1(UnsubscribeScanResultNotification,
+               void(uint32_t interface_index));
   MOCK_METHOD1(AbortScan, bool(uint32_t interface_index));
+  MOCK_METHOD1(StopScheduledScan, bool(uint32_t interface_index));
 
+  MOCK_METHOD2(SubscribeScanResultNotification,void(
+      uint32_t interface_index,
+      OnScanResultsReadyHandler handler));
   MOCK_METHOD2(GetScanResult, bool(
       uint32_t interface_index,
       std::vector<::com::android::server::wifi::wificond::NativeScanResult>* out_scan_results));
@@ -42,12 +48,15 @@ class MockScanUtils : public ScanUtils {
       const std::vector<uint32_t>& freqs,
       int* error_code));
 
-  MOCK_METHOD2(SubscribeScanResultNotification,void(
+  MOCK_METHOD8(StartScheduledScan, bool(
       uint32_t interface_index,
-      OnScanResultsReadyHandler handler));
-
-  MOCK_METHOD1(UnsubscribeScanResultNotification,
-               void(uint32_t interface_index));
+      uint32_t interval_ms,
+      int32_t rssi_threshold,
+      bool request_random_mac,
+      const std::vector<std::vector<uint8_t>>& scan_ssids,
+      const std::vector<std::vector<uint8_t>>& match_ssids,
+      const std::vector<uint32_t>& freqs,
+      int* error_code));
 
 };  // class MockScanUtils
 

diff --git a/tests/offload_scan_manager_test.cpp b/tests/offload_scan_manager_test.cpp
index 7b0bbeb..2dbf953 100644 (file)
--- a/tests/offload_scan_manager_test.cpp
+++ b/tests/offload_scan_manager_test.cpp
@@ -47,6 +47,7 @@ using com::android::server::wifi::wificond::NativeScanStats;
 using testing::NiceMock;
 using testing::_;
 using testing::Invoke;
+using std::shared_ptr;
 using std::unique_ptr;
 using std::vector;
 using std::bind;
@@ -109,7 +110,7 @@ class OffloadScanManagerTest : public ::testing::Test {
   sp<NiceMock<MockOffload>> mock_offload_{new NiceMock<MockOffload>()};
   sp<OffloadCallback> offload_callback_;
   sp<OffloadDeathRecipient> death_recipient_;
-  unique_ptr<NiceMock<MockOffloadServiceUtils>> mock_offload_service_utils_{
+  shared_ptr<NiceMock<MockOffloadServiceUtils>> mock_offload_service_utils_{
       new NiceMock<MockOffloadServiceUtils>()};
   unique_ptr<OffloadScanManager> offload_scan_manager_;
   OffloadStatus status;
@@ -130,7 +131,7 @@ TEST_F(OffloadScanManagerTest, BinderDeathRegisteredCookieAndService) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
   offload_scan_manager_.reset(new OffloadScanManager(
-      mock_offload_service_utils_.get(),
+      mock_offload_service_utils_,
       [](vector<NativeScanResult> scanResult) -> void {}));
   death_recipient_->serviceDied(cookie_, mock_offload_);
   EXPECT_EQ(OffloadScanManager::kNoService,
@@ -146,7 +147,7 @@ TEST_F(OffloadScanManagerTest, BinderDeathUnregisteredCookie) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
   offload_scan_manager_.reset(new OffloadScanManager(
-      mock_offload_service_utils_.get(),
+      mock_offload_service_utils_,
       [](vector<NativeScanResult> scanResult) -> void {}));
   death_recipient_->serviceDied(kDeathCode, mock_offload_);
   EXPECT_FALSE(OffloadScanManager::kNoService ==
@@ -154,15 +155,6 @@ TEST_F(OffloadScanManagerTest, BinderDeathUnregisteredCookie) {
 }
 
 /**
- * Testing OffloadScanManager with OffloadServiceUtils null argument
- */
-TEST_F(OffloadScanManagerTest, ServiceUtilsNotAvailableTest) {
-  offload_scan_manager_.reset(new OffloadScanManager(nullptr, nullptr));
-  EXPECT_EQ(OffloadScanManager::kNoService,
-            offload_scan_manager_->getOffloadStatus());
-}
-
-/**
  * Testing OffloadScanManager with no handle on Offloal HAL service
  * and no registered handler for Offload Scan results
  */
@@ -171,7 +163,7 @@ TEST_F(OffloadScanManagerTest, ServiceNotAvailableTest) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(nullptr));
   offload_scan_manager_.reset(new OffloadScanManager(
-      mock_offload_service_utils_.get(),
+      mock_offload_service_utils_,
       [](vector<NativeScanResult> scanResult) -> void {}));
   EXPECT_EQ(OffloadScanManager::kNoService,
             offload_scan_manager_->getOffloadStatus());
@@ -188,7 +180,7 @@ TEST_F(OffloadScanManagerTest, ServiceAvailableTest) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
   offload_scan_manager_.reset(new OffloadScanManager(
-      mock_offload_service_utils_.get(),
+      mock_offload_service_utils_,
       [](vector<NativeScanResult> scanResult) -> void {}));
   EXPECT_EQ(OffloadScanManager::kNoError,
             offload_scan_manager_->getOffloadStatus());
@@ -207,7 +199,7 @@ TEST_F(OffloadScanManagerTest, CallbackInvokedTest) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
   offload_scan_manager_.reset(new OffloadScanManager(
-      mock_offload_service_utils_.get(),
+      mock_offload_service_utils_,
       [&callback_invoked](vector<NativeScanResult> scanResult) -> void {
         callback_invoked = true;
       }));
@@ -228,7 +220,7 @@ TEST_F(OffloadScanManagerTest, ErrorCallbackInvokedTest) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
   offload_scan_manager_.reset(new OffloadScanManager(
-      mock_offload_service_utils_.get(),
+      mock_offload_service_utils_,
       [](vector<NativeScanResult> scanResult) -> void {}));
   OffloadStatus status =
       OffloadTestUtils::createOffloadStatus(OffloadStatusCode::ERROR);
@@ -248,7 +240,7 @@ TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsOk) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
   offload_scan_manager_.reset(new OffloadScanManager(
-      mock_offload_service_utils_.get(),
+      mock_offload_service_utils_,
       [](vector<NativeScanResult> scanResult) -> void {}));
   EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _));
   EXPECT_CALL(*mock_offload_, configureScans(_, _, _));
@@ -268,7 +260,7 @@ TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsNotAvailable) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(nullptr));
   offload_scan_manager_.reset(new OffloadScanManager(
-      mock_offload_service_utils_.get(),
+      mock_offload_service_utils_,
       [](vector<NativeScanResult> scanResult) -> void {}));
   OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
   bool result = offload_scan_manager_->startScan(
@@ -289,7 +281,7 @@ TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsNotConnected) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
   offload_scan_manager_.reset(new OffloadScanManager(
-      mock_offload_service_utils_.get(),
+      mock_offload_service_utils_,
       [](vector<NativeScanResult> scanResult) -> void {}));
   OffloadStatus status =
       OffloadTestUtils::createOffloadStatus(OffloadStatusCode::NO_CONNECTION);
@@ -313,7 +305,7 @@ TEST_F(OffloadScanManagerTest, StartScanTwiceTestWhenServiceIsOk) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
   offload_scan_manager_.reset(new OffloadScanManager(
-      mock_offload_service_utils_.get(),
+      mock_offload_service_utils_,
       [](vector<NativeScanResult> scanResult) -> void {}));
   EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)).Times(1);
   EXPECT_CALL(*mock_offload_, configureScans(_, _, _)).Times(2);
@@ -339,7 +331,7 @@ TEST_F(OffloadScanManagerTest, StopScanTestWhenServiceIsOk) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
   offload_scan_manager_.reset(new OffloadScanManager(
-      mock_offload_service_utils_.get(),
+      mock_offload_service_utils_,
       [](vector<NativeScanResult> scanResult) -> void {}));
   EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _));
   EXPECT_CALL(*mock_offload_, configureScans(_, _, _));
@@ -364,7 +356,7 @@ TEST_F(OffloadScanManagerTest, StopScanTestWithoutStartWhenServiceIsOk) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
   offload_scan_manager_.reset(new OffloadScanManager(
-      mock_offload_service_utils_.get(),
+      mock_offload_service_utils_,
       [](vector<NativeScanResult> scanResult) -> void {}));
   OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
   bool result = offload_scan_manager_->stopScan(&reason_code);
@@ -382,7 +374,7 @@ TEST_F(OffloadScanManagerTest, StopScanTestWhenServiceIsNotConnectedAnymore) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
   offload_scan_manager_.reset(new OffloadScanManager(
-      mock_offload_service_utils_.get(),
+      mock_offload_service_utils_,
       [](vector<NativeScanResult> scanResult) -> void {}));
   EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _));
   EXPECT_CALL(*mock_offload_, configureScans(_, _, _));
@@ -410,7 +402,7 @@ TEST_F(OffloadScanManagerTest, getScanStatsTestWhenServiceIsOk) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
   offload_scan_manager_.reset(new OffloadScanManager(
-      mock_offload_service_utils_.get(),
+      mock_offload_service_utils_,
       [](vector<NativeScanResult> scanResult) -> void {}));
   EXPECT_CALL(*mock_offload_, getScanStats(_));
   NativeScanStats stats;
@@ -429,7 +421,7 @@ TEST_F(OffloadScanManagerTest, getScanStatsTestWhenServiceIsNotOk) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
   offload_scan_manager_.reset(new OffloadScanManager(
-      mock_offload_service_utils_.get(),
+      mock_offload_service_utils_,
       [](vector<NativeScanResult> scanResult) -> void {}));
   OffloadStatus status =
       OffloadTestUtils::createOffloadStatus(OffloadStatusCode::NO_CONNECTION);
@@ -451,7 +443,7 @@ TEST_F(OffloadScanManagerTest, StartScanFailedTest) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
   offload_scan_manager_.reset(new OffloadScanManager(
-      mock_offload_service_utils_.get(),
+      mock_offload_service_utils_,
       [](vector<NativeScanResult> scanResult) -> void {}));
   EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)).Times(0);
   EXPECT_CALL(*mock_offload_, configureScans(_, _, _)).Times(1);
@@ -475,7 +467,7 @@ TEST_F(OffloadScanManagerTest, getScanStatsFailedTest) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
   offload_scan_manager_.reset(new OffloadScanManager(
-      mock_offload_service_utils_.get(),
+      mock_offload_service_utils_,
       [](vector<NativeScanResult> scanResult) -> void {}));
   status = OffloadTestUtils::createOffloadStatus(OffloadStatusCode::TIMEOUT);
   EXPECT_CALL(*mock_offload_, getScanStats(_));

diff --git a/tests/scanner_unittest.cpp b/tests/scanner_unittest.cpp
index ce09923..85f6330 100644 (file)
--- a/tests/scanner_unittest.cpp
+++ b/tests/scanner_unittest.cpp
@@ -25,17 +25,21 @@
 #include "wificond/tests/mock_client_interface_impl.h"
 #include "wificond/tests/mock_netlink_manager.h"
 #include "wificond/tests/mock_netlink_utils.h"
+#include "wificond/tests/mock_offload_service_utils.h"
 #include "wificond/tests/mock_scan_utils.h"
 
 using ::android::binder::Status;
 using ::android::wifi_system::MockInterfaceTool;
 using ::android::wifi_system::MockSupplicantManager;
 using ::com::android::server::wifi::wificond::SingleScanSettings;
+using ::com::android::server::wifi::wificond::PnoSettings;
 using ::com::android::server::wifi::wificond::NativeScanResult;
 using ::testing::Invoke;
 using ::testing::NiceMock;
 using ::testing::Return;
 using ::testing::_;
+using std::shared_ptr;
+using std::unique_ptr;
 using std::vector;
 
 using namespace std::placeholders;
@@ -69,6 +73,17 @@ bool ReturnErrorCodeForScanRequest(
 
 class ScannerTest : public ::testing::Test {
  protected:
+  void SetUp() override {
+   ON_CALL(*offload_service_utils_, IsOffloadScanSupported()).WillByDefault(
+      Return(false));
+   netlink_scanner_.reset(new ScannerImpl(
+       kFakeWiphyIndex, kFakeInterfaceIndex,
+       scan_capabilities_, wiphy_features_,
+       &client_interface_impl_,
+       &netlink_utils_, &scan_utils_, offload_service_utils_));
+  }
+
+  unique_ptr<ScannerImpl> netlink_scanner_;
   NiceMock<MockNetlinkManager> netlink_manager_;
   NiceMock<MockNetlinkUtils> netlink_utils_{&netlink_manager_};
   NiceMock<MockScanUtils> scan_utils_{&netlink_manager_};
@@ -76,19 +91,16 @@ class ScannerTest : public ::testing::Test {
   NiceMock<MockSupplicantManager> supplicant_manager_;
   NiceMock<MockClientInterfaceImpl> client_interface_impl_{
       &if_tool_, &supplicant_manager_, &netlink_utils_, &scan_utils_};
+  shared_ptr<NiceMock<MockOffloadServiceUtils>> offload_service_utils_{
+      new NiceMock<MockOffloadServiceUtils>()};
   ScanCapabilities scan_capabilities_;
   WiphyFeatures wiphy_features_;
-  ScannerImpl scanner_{
-    kFakeWiphyIndex, kFakeInterfaceIndex,
-    scan_capabilities_, wiphy_features_,
-    &client_interface_impl_,
-    &netlink_utils_, &scan_utils_};
 };
 
 TEST_F(ScannerTest, TestSingleScan) {
   EXPECT_CALL(scan_utils_, Scan(_, _, _, _, _)).WillOnce(Return(true));
   bool success = false;
-  EXPECT_TRUE(scanner_.scan(SingleScanSettings(), &success).isOk());
+  EXPECT_TRUE(netlink_scanner_->scan(SingleScanSettings(), &success).isOk());
   EXPECT_TRUE(success);
 }
 
@@ -100,7 +112,7 @@ TEST_F(ScannerTest, TestSingleScanFailure) {
               ReturnErrorCodeForScanRequest, EBUSY, _1, _2, _3, _4, _5)));
 
   bool success = false;
-  EXPECT_TRUE(scanner_.scan(SingleScanSettings(), &success).isOk());
+  EXPECT_TRUE(netlink_scanner_->scan(SingleScanSettings(), &success).isOk());
   EXPECT_FALSE(success);
 }
 
@@ -113,33 +125,48 @@ TEST_F(ScannerTest, TestProcessAbortsOnScanReturningNoDeviceError) {
 
   bool success_ignored;
   EXPECT_DEATH(
-      scanner_.scan(SingleScanSettings(), &success_ignored),
+      netlink_scanner_->scan(SingleScanSettings(), &success_ignored),
       "Driver is in a bad state*");
 }
 
 TEST_F(ScannerTest, TestAbortScan) {
   bool single_scan_success = false;
   EXPECT_CALL(scan_utils_, Scan(_, _, _, _, _)).WillOnce(Return(true));
-  EXPECT_TRUE(scanner_.scan(SingleScanSettings(),
+  EXPECT_TRUE(netlink_scanner_->scan(SingleScanSettings(),
                             &single_scan_success).isOk());
   EXPECT_TRUE(single_scan_success);
 
   EXPECT_CALL(scan_utils_, AbortScan(_));
-  EXPECT_TRUE(scanner_.abortScan().isOk());
+  EXPECT_TRUE(netlink_scanner_->abortScan().isOk());
 }
 
 TEST_F(ScannerTest, TestAbortScanNotIssuedIfNoOngoingScan) {
   EXPECT_CALL(scan_utils_, AbortScan(_)).Times(0);
-  EXPECT_TRUE(scanner_.abortScan().isOk());
+  EXPECT_TRUE(netlink_scanner_->abortScan().isOk());
 }
 
 TEST_F(ScannerTest, TestGetScanResults) {
   vector<NativeScanResult> scan_results;
   EXPECT_CALL(scan_utils_, GetScanResult(_, _)).WillOnce(Return(true));
-  EXPECT_TRUE(scanner_.getScanResults(&scan_results).isOk());
+  EXPECT_TRUE(netlink_scanner_->getScanResults(&scan_results).isOk());
 }
 
-//TODO(b/33452931): Add more test cases for ScannerImpl.
+TEST_F(ScannerTest, TestStartPnoScanViaNetlink) {
+  bool success = false;
+  EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _)).
+              WillOnce(Return(true));
+  EXPECT_TRUE(netlink_scanner_->startPnoScan(PnoSettings(), &success).isOk());
+  EXPECT_TRUE(success);
+}
+
+TEST_F(ScannerTest, TestStopPnoScanViaNetlink) {
+  bool success = false;
+  // StopScheduledScan() will be called no matter if there is an ongoing
+  // scheduled scan or not. This is for making the system more robust.
+  EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true));
+  EXPECT_TRUE(netlink_scanner_->stopPnoScan(&success).isOk());
+  EXPECT_TRUE(success);
+}
 
 }  // namespace wificond
 }  // namespace android