Commit: 7a3d8ddff0ea3bca99fb3e554651e1541a93121e - system-connectivity-wificond (git)

system/connectivity/wificond

Commit MetaInfo

• Révision: 7a3d8ddff0ea3bca99fb3e554651e1541a93121e (tree)
• l'heure: 2017-07-13 03:11:07
• Auteur: Ningyuan Wang <nywang@goog...>
• Commiter: Ningyuan Wang

Message de Log

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

Change Summary

• modified: client_interface_impl.cpp
• modified: client_interface_impl.h
• modified: scanning/offload/offload_scan_manager.cpp
• modified: scanning/offload/offload_scan_manager.h
• modified: scanning/offload/offload_service_utils.cpp
• modified: scanning/offload/offload_service_utils.h
• modified: scanning/scanner_impl.cpp
• modified: scanning/scanner_impl.h
• modified: tests/mock_offload_service_utils.h
• modified: tests/mock_scan_utils.h
• modified: tests/offload_scan_manager_test.cpp
• modified: tests/scanner_unittest.cpp

Modification

--- 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() {

--- 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_;

--- 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";

--- 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(

--- 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) {}

--- 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(

--- 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() {

--- 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(

--- 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,

--- 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
 

--- 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(_));

--- 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