Wificond ScannerImpl Unit testing Offload HAL

am: 8f574ac480

Change-Id: I6167b0f9d03b366caca1058bfcfaa91e38a0dc90

3 files changed, 227 insertions, 41 deletions

diff --git a/scanning/offload/offload_scan_manager.h b/scanning/offload/offload_scan_manager.h
index 7b23d8e..6be3ec0 100644
--- a/scanning/offload/offload_scan_manager.h
+++ b/scanning/offload/offload_scan_manager.h
@@ -97,23 +97,24 @@ class OffloadScanManager {
    * settings. Internally calls Offload HAL service with configureScans()
    * and subscribeScanResults() APIs. Reason code indicates failure reason.
    */
-  bool startScan(uint32_t /* interval_ms */, int32_t /* rssi_threshold */,
-                 const std::vector<std::vector<uint8_t>>& /* scan_ssids */,
-                 const std::vector<std::vector<uint8_t>>& /* match_ssids */,
-                 const std::vector<uint8_t>& /* match_security */,
-                 const std::vector<uint32_t>& /* freqs */,
-                 ReasonCode* /* failure reason */);
+  virtual bool startScan(
+      uint32_t /* interval_ms */, int32_t /* rssi_threshold */,
+      const std::vector<std::vector<uint8_t>>& /* scan_ssids */,
+      const std::vector<std::vector<uint8_t>>& /* match_ssids */,
+      const std::vector<uint8_t>& /* match_security */,
+      const std::vector<uint32_t>& /* freqs */,
+      ReasonCode* /* failure reason */);
   /* Request stop of offload scans, returns true if the operation succeeds
    * Otherwise, returns false. Reason code is updated in case of failure.
    */
-  bool stopScan(ReasonCode* /* failure reason */);
+  virtual bool stopScan(ReasonCode* /* failure reason */);
   /* Get statistics for scans performed by Offload HAL */
-  bool getScanStats(
+  virtual bool getScanStats(
       ::com::android::server::wifi::wificond::NativeScanStats* /* scanStats */);
   /* Otain status of the Offload HAL service */
-  StatusCode getOffloadStatus() const;
+  virtual StatusCode getOffloadStatus() const;
   /* Returns the most recent scan result available from Offload HAL */
-  bool getScanResults(
+  virtual bool getScanResults(
       std::vector<::com::android::server::wifi::wificond::NativeScanResult>*
           out_scan_results);
 
@@ -129,10 +130,12 @@ class OffloadScanManager {
       OffloadScanManager::ReasonCode* reason_code);
   bool GetScanStats(
       ::com::android::server::wifi::wificond::NativeScanStats* stats);
-  bool SubscribeScanResults(OffloadScanManager::ReasonCode* reason_code);
-  bool ConfigureScans(android::hardware::wifi::offload::V1_0::ScanParam,
-                      android::hardware::wifi::offload::V1_0::ScanFilter,
-                      OffloadScanManager::ReasonCode* reason_code);
+  bool SubscribeScanResults(
+      OffloadScanManager::ReasonCode* reason_code);
+  bool ConfigureScans(
+      android::hardware::wifi::offload::V1_0::ScanParam,
+      android::hardware::wifi::offload::V1_0::ScanFilter,
+      OffloadScanManager::ReasonCode* reason_code);
   bool InitServiceIfNeeded();
   bool InitService();
 
diff --git a/scanning/scanner_impl.cpp b/scanning/scanner_impl.cpp
index b14d788..0f6ab52 100644
--- a/scanning/scanner_impl.cpp
+++ b/scanning/scanner_impl.cpp
@@ -233,6 +233,7 @@ Status ScannerImpl::startPnoScan(const PnoSettings& pno_settings,
                                  bool* out_success) {
   pno_settings_ = pno_settings;
   pno_scan_results_from_offload_ = false;
+  LOG(VERBOSE) << "startPnoScan";
   if (offload_scan_supported_ && StartPnoScanOffload(pno_settings)) {
     // scanning over offload succeeded
     *out_success = true;
@@ -252,7 +253,6 @@ bool ScannerImpl::StartPnoScanOffload(const PnoSettings& pno_settings) {
 
   ParsePnoSettings(pno_settings, &scan_ssids, &match_ssids, &freqs,
                    &match_security);
-
   pno_scan_running_over_offload_ = offload_scan_manager_->startScan(
       pno_settings.interval_ms_,
       // TODO: honor both rssi thresholds.
@@ -464,6 +464,7 @@ void ScannerImpl::OnSchedScanResultsReady(uint32_t interface_index,
       pno_scan_started_ = false;
     } else {
       LOG(INFO) << "Pno scan result ready event";
+      pno_scan_results_from_offload_ = false;
       pno_scan_event_handler_->OnPnoNetworkFound();
     }
   }
@@ -540,7 +541,7 @@ void ScannerImpl::OnOffloadError(
       LOG(WARNING) << "Invalid Error code";
       break;
   }
-  bool success;
+  bool success = false;
   // Stop scans over Offload HAL and request them over netlink
   stopPnoScan(&success);
   if (success) {
diff --git a/tests/scanner_unittest.cpp b/tests/scanner_unittest.cpp
index 1a93e31..d69e8b1 100644
--- a/tests/scanner_unittest.cpp
+++ b/tests/scanner_unittest.cpp
@@ -21,6 +21,7 @@
 #include <wifi_system_test/mock_interface_tool.h>
 #include <wifi_system_test/mock_supplicant_manager.h>
 
+#include "wificond/scanning/offload/offload_scan_utils.h"
 #include "wificond/scanning/scanner_impl.h"
 #include "wificond/tests/mock_client_interface_impl.h"
 #include "wificond/tests/mock_netlink_manager.h"
@@ -29,6 +30,7 @@
 #include "wificond/tests/mock_offload_scan_manager.h"
 #include "wificond/tests/mock_offload_service_utils.h"
 #include "wificond/tests/mock_scan_utils.h"
+#include "wificond/tests/offload_test_utils.h"
 
 using ::android::binder::Status;
 using ::android::wifi_system::MockInterfaceTool;
@@ -36,6 +38,7 @@ 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 android::hardware::wifi::offload::V1_0::ScanResult;
 using ::testing::Invoke;
 using ::testing::NiceMock;
 using ::testing::Return;
@@ -86,25 +89,36 @@ bool CaptureSchedScanIntervalSetting(
   return true;
 }
 
+bool ReturnOffloadScanResults(
+    std::vector<NativeScanResult>* native_scan_results_,
+    const std::vector<ScanResult>& offload_scan_results) {
+  return OffloadScanUtils::convertToNativeScanResults(offload_scan_results,
+                                                      native_scan_results_);
+}
+
+bool ReturnNetlinkScanResults(
+    uint32_t interface_index,
+    std::vector<NativeScanResult>* native_scan_results_,
+    const std::vector<ScanResult>& offload_scan_results) {
+  return OffloadScanUtils::convertToNativeScanResults(offload_scan_results,
+                                                      native_scan_results_);
+}
+
 }  // namespace
 
 class ScannerTest : public ::testing::Test {
  protected:
   void SetUp() override {
-   ON_CALL(*offload_service_utils_, IsOffloadScanSupported()).WillByDefault(
-      Return(false));
-   ON_CALL(*offload_service_utils_, GetOffloadScanManager(_, _))
-       .WillByDefault(Return(offload_scan_manager_));
-   ON_CALL(*offload_service_utils_, GetOffloadScanCallbackInterface(_))
-       .WillByDefault(Return(offload_scan_callback_interface_));
-   netlink_scanner_.reset(new ScannerImpl(
-       kFakeWiphyIndex, kFakeInterfaceIndex,
-       scan_capabilities_, wiphy_features_,
-       &client_interface_impl_,
-       &netlink_utils_, &scan_utils_, offload_service_utils_));
+    ON_CALL(*offload_service_utils_, GetOffloadScanManager(_, _))
+        .WillByDefault(Return(offload_scan_manager_));
+    ON_CALL(*offload_service_utils_, GetOffloadScanCallbackInterface(_))
+        .WillByDefault(Return(offload_scan_callback_interface_));
+    dummy_scan_results_ = OffloadTestUtils::createOffloadScanResults();
   }
 
-  unique_ptr<ScannerImpl> netlink_scanner_;
+  void TearDown() override { dummy_scan_results_.clear(); }
+
+  unique_ptr<ScannerImpl> scanner_impl_;
   NiceMock<MockNetlinkManager> netlink_manager_;
   NiceMock<MockNetlinkUtils> netlink_utils_{&netlink_manager_};
   NiceMock<MockScanUtils> scan_utils_{&netlink_manager_};
@@ -117,22 +131,31 @@ class ScannerTest : public ::testing::Test {
   shared_ptr<NiceMock<MockOffloadScanCallbackInterfaceImpl>>
       offload_scan_callback_interface_{
           new NiceMock<MockOffloadScanCallbackInterfaceImpl>(
-              netlink_scanner_.get())};
+              scanner_impl_.get())};
   std::shared_ptr<NiceMock<MockOffloadScanManager>> offload_scan_manager_{
       new NiceMock<MockOffloadScanManager>(offload_service_utils_,
                                            offload_scan_callback_interface_)};
   ScanCapabilities scan_capabilities_;
   WiphyFeatures wiphy_features_;
+  std::vector<ScanResult> dummy_scan_results_;
 };
 
 TEST_F(ScannerTest, TestSingleScan) {
   EXPECT_CALL(scan_utils_, Scan(_, _, _, _, _)).WillOnce(Return(true));
   bool success = false;
-  EXPECT_TRUE(netlink_scanner_->scan(SingleScanSettings(), &success).isOk());
+  scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+                                      scan_capabilities_, wiphy_features_,
+                                      &client_interface_impl_, &netlink_utils_,
+                                      &scan_utils_, offload_service_utils_));
+  EXPECT_TRUE(scanner_impl_->scan(SingleScanSettings(), &success).isOk());
   EXPECT_TRUE(success);
 }
 
 TEST_F(ScannerTest, TestSingleScanFailure) {
+  scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+                                      scan_capabilities_, wiphy_features_,
+                                      &client_interface_impl_, &netlink_utils_,
+                                      &scan_utils_, offload_service_utils_));
   EXPECT_CALL(
       scan_utils_,
       Scan(_, _, _, _, _)).
@@ -140,11 +163,15 @@ TEST_F(ScannerTest, TestSingleScanFailure) {
               ReturnErrorCodeForScanRequest, EBUSY, _1, _2, _3, _4, _5)));
 
   bool success = false;
-  EXPECT_TRUE(netlink_scanner_->scan(SingleScanSettings(), &success).isOk());
+  EXPECT_TRUE(scanner_impl_->scan(SingleScanSettings(), &success).isOk());
   EXPECT_FALSE(success);
 }
 
 TEST_F(ScannerTest, TestProcessAbortsOnScanReturningNoDeviceError) {
+  scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+                                      scan_capabilities_, wiphy_features_,
+                                      &client_interface_impl_, &netlink_utils_,
+                                      &scan_utils_, offload_service_utils_));
   ON_CALL(
       scan_utils_,
       Scan(_, _, _, _, _)).
@@ -152,47 +179,202 @@ TEST_F(ScannerTest, TestProcessAbortsOnScanReturningNoDeviceError) {
               ReturnErrorCodeForScanRequest, ENODEV, _1, _2, _3, _4, _5)));
 
   bool success_ignored;
-  EXPECT_DEATH(
-      netlink_scanner_->scan(SingleScanSettings(), &success_ignored),
-      "Driver is in a bad state*");
+  EXPECT_DEATH(scanner_impl_->scan(SingleScanSettings(), &success_ignored),
+               "Driver is in a bad state*");
 }
 
 TEST_F(ScannerTest, TestAbortScan) {
   bool single_scan_success = false;
+  scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+                                      scan_capabilities_, wiphy_features_,
+                                      &client_interface_impl_, &netlink_utils_,
+                                      &scan_utils_, offload_service_utils_));
   EXPECT_CALL(scan_utils_, Scan(_, _, _, _, _)).WillOnce(Return(true));
-  EXPECT_TRUE(netlink_scanner_->scan(SingleScanSettings(),
-                            &single_scan_success).isOk());
+  EXPECT_TRUE(
+      scanner_impl_->scan(SingleScanSettings(), &single_scan_success).isOk());
   EXPECT_TRUE(single_scan_success);
 
   EXPECT_CALL(scan_utils_, AbortScan(_));
-  EXPECT_TRUE(netlink_scanner_->abortScan().isOk());
+  EXPECT_TRUE(scanner_impl_->abortScan().isOk());
 }
 
 TEST_F(ScannerTest, TestAbortScanNotIssuedIfNoOngoingScan) {
+  scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+                                      scan_capabilities_, wiphy_features_,
+                                      &client_interface_impl_, &netlink_utils_,
+                                      &scan_utils_, offload_service_utils_));
   EXPECT_CALL(scan_utils_, AbortScan(_)).Times(0);
-  EXPECT_TRUE(netlink_scanner_->abortScan().isOk());
+  EXPECT_TRUE(scanner_impl_->abortScan().isOk());
 }
 
 TEST_F(ScannerTest, TestGetScanResults) {
   vector<NativeScanResult> scan_results;
+  scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+                                      scan_capabilities_, wiphy_features_,
+                                      &client_interface_impl_, &netlink_utils_,
+                                      &scan_utils_, offload_service_utils_));
   EXPECT_CALL(scan_utils_, GetScanResult(_, _)).WillOnce(Return(true));
-  EXPECT_TRUE(netlink_scanner_->getScanResults(&scan_results).isOk());
+  EXPECT_TRUE(scanner_impl_->getScanResults(&scan_results).isOk());
 }
 
 TEST_F(ScannerTest, TestStartPnoScanViaNetlink) {
   bool success = false;
+  EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
+      .Times(1)
+      .WillRepeatedly(Return(false));
+  scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+                                      scan_capabilities_, wiphy_features_,
+                                      &client_interface_impl_, &netlink_utils_,
+                                      &scan_utils_, offload_service_utils_));
   EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _)).
               WillOnce(Return(true));
-  EXPECT_TRUE(netlink_scanner_->startPnoScan(PnoSettings(), &success).isOk());
+  EXPECT_TRUE(scanner_impl_->startPnoScan(PnoSettings(), &success).isOk());
   EXPECT_TRUE(success);
 }
 
 TEST_F(ScannerTest, TestStopPnoScanViaNetlink) {
   bool success = false;
+  EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
+      .Times(1)
+      .WillRepeatedly(Return(false));
+  scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+                                      scan_capabilities_, wiphy_features_,
+                                      &client_interface_impl_, &netlink_utils_,
+                                      &scan_utils_, offload_service_utils_));
   // 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(scanner_impl_->stopPnoScan(&success).isOk());
+  EXPECT_TRUE(success);
+}
+
+TEST_F(ScannerTest, TestStartScanOverOffload) {
+  bool success = false;
+  EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
+      .Times(1)
+      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _))
+      .Times(1)
+      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*offload_scan_manager_, stopScan(_))
+      .Times(1)
+      .WillRepeatedly(Return(true));
+  scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+                                      scan_capabilities_, wiphy_features_,
+                                      &client_interface_impl_, &netlink_utils_,
+                                      &scan_utils_, offload_service_utils_));
+  scanner_impl_->startPnoScan(PnoSettings(), &success);
+  EXPECT_TRUE(success);
+  scanner_impl_->stopPnoScan(&success);
+  EXPECT_TRUE(success);
+}
+
+TEST_F(ScannerTest, TestStartScanOverNetlinkFallback) {
+  bool success = false;
+  ON_CALL(*offload_service_utils_, IsOffloadScanSupported())
+      .WillByDefault(Return(true));
+  scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+                                      scan_capabilities_, wiphy_features_,
+                                      &client_interface_impl_, &netlink_utils_,
+                                      &scan_utils_, offload_service_utils_));
+  EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _))
+      .WillOnce(Return(false));
+  EXPECT_CALL(*offload_scan_manager_, stopScan(_)).Times(0);
+  EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _))
+      .WillOnce(Return(true));
+  EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true));
+  EXPECT_TRUE(scanner_impl_->startPnoScan(PnoSettings(), &success).isOk());
+  EXPECT_TRUE(success == true);
+  scanner_impl_->stopPnoScan(&success);
+  EXPECT_TRUE(success);
+}
+
+TEST_F(ScannerTest, TestAsyncErrorOverOffload) {
+  bool success = false;
+  EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
+      .Times(1)
+      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _))
+      .Times(1)
+      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*offload_scan_manager_, stopScan(_))
+      .Times(1)
+      .WillRepeatedly(Return(true));
+  scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+                                      scan_capabilities_, wiphy_features_,
+                                      &client_interface_impl_, &netlink_utils_,
+                                      &scan_utils_, offload_service_utils_));
+  EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _))
+      .WillOnce(Return(true));
+  EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true));
+  scanner_impl_->startPnoScan(PnoSettings(), &success);
+  EXPECT_TRUE(success);
+  scanner_impl_->OnOffloadError(
+      OffloadScanCallbackInterface::AsyncErrorReason::REMOTE_FAILURE);
+  scanner_impl_->stopPnoScan(&success);
+  EXPECT_TRUE(success);
+}
+
+TEST_F(ScannerTest, TestGetScanResultsFromOffload) {
+  bool success = false;
+  EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
+      .Times(1)
+      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _))
+      .Times(1)
+      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*offload_scan_manager_, getScanResults(_))
+      .Times(1)
+      .WillOnce(
+          Invoke(bind(ReturnOffloadScanResults, _1, dummy_scan_results_)));
+  EXPECT_CALL(*offload_scan_manager_, stopScan(_))
+      .Times(1)
+      .WillRepeatedly(Return(true));
+  scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+                                      scan_capabilities_, wiphy_features_,
+                                      &client_interface_impl_, &netlink_utils_,
+                                      &scan_utils_, offload_service_utils_));
+  scanner_impl_->startPnoScan(PnoSettings(), &success);
+  EXPECT_TRUE(success);
+  scanner_impl_->OnOffloadScanResult();
+  std::vector<NativeScanResult> scan_results;
+  EXPECT_TRUE(scanner_impl_->getPnoScanResults(&scan_results).isOk());
+  EXPECT_FALSE(scan_results.empty());
+  scanner_impl_->stopPnoScan(&success);
+  EXPECT_TRUE(success);
+}
+
+TEST_F(ScannerTest, TestGetScanResultsWhenOffloadFails) {
+  bool success = false;
+  EXPECT_CALL(*offload_service_utils_, IsOffloadScanSupported())
+      .Times(1)
+      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*offload_scan_manager_, startScan(_, _, _, _, _, _, _))
+      .Times(1)
+      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*offload_scan_manager_, stopScan(_))
+      .Times(1)
+      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*offload_scan_manager_, getScanResults(_)).Times(0);
+  EXPECT_CALL(scan_utils_, GetScanResult(_, _))
+      .Times(1)
+      .WillOnce(
+          Invoke(bind(ReturnNetlinkScanResults, _1, _2, dummy_scan_results_)));
+  scanner_impl_.reset(new ScannerImpl(kFakeWiphyIndex, kFakeInterfaceIndex,
+                                      scan_capabilities_, wiphy_features_,
+                                      &client_interface_impl_, &netlink_utils_,
+                                      &scan_utils_, offload_service_utils_));
+  EXPECT_CALL(scan_utils_, StartScheduledScan(_, _, _, _, _, _, _, _))
+      .WillOnce(Return(true));
+  EXPECT_CALL(scan_utils_, StopScheduledScan(_)).WillOnce(Return(true));
+  EXPECT_TRUE(scanner_impl_->startPnoScan(PnoSettings(), &success).isOk());
+  EXPECT_TRUE(success);
+  scanner_impl_->OnOffloadError(
+      OffloadScanCallbackInterface::AsyncErrorReason::REMOTE_FAILURE);
+  std::vector<NativeScanResult> scan_results;
+  EXPECT_TRUE(scanner_impl_->getPnoScanResults(&scan_results).isOk());
+  EXPECT_FALSE(scan_results.empty());
+  scanner_impl_->stopPnoScan(&success);
   EXPECT_TRUE(success);
 }