Wificond: Handle Error callback from Offload HAL

Client code changes to handle error can be reported by the Offload HAL
service and corresponding unit tests.

Bug: 32842314
Test: Unit tests
Change-Id: I17666c9faa2979c894a3b76559e3b36ed92ff2a9

5 files changed, 144 insertions, 29 deletions

diff --git a/tests/mock_offload_callback_handlers.cpp b/tests/mock_offload_callback_handlers.cpp
new file mode 100644
index 0000000..125d7fd
--- /dev/null
+++ b/tests/mock_offload_callback_handlers.cpp
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "wificond/tests/mock_offload_callback_handlers.h"
+
+namespace android {
+namespace wificond {
+
+MockOffloadCallbackHandlers::MockOffloadCallbackHandlers() {
+}
+
+} // namespace wificond
+} // namespace android
diff --git a/tests/mock_offload_callback_handlers.h b/tests/mock_offload_callback_handlers.h
new file mode 100644
index 0000000..09b2e14
--- /dev/null
+++ b/tests/mock_offload_callback_handlers.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef WIFICOND_TESTS_MOCK_OFFLOAD_CALLBACK_HANDLERS_H_
+#define WIFICOND_TESTS_MOCK_OFFLOAD_CALLBACK_HANDLERS_H_
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "wificond/scanning/offload/offload_callback_handlers.h"
+#include <android/hardware/wifi/offload/1.0/IOffload.h>
+
+using android::hardware::wifi::offload::V1_0::ScanResult;
+using android::hardware::wifi::offload::V1_0::OffloadStatus;
+
+namespace android {
+namespace wificond {
+
+class MockOffloadCallbackHandlers : public OffloadCallbackHandlers {
+ public:
+  MockOffloadCallbackHandlers();
+  ~MockOffloadCallbackHandlers() override = default;
+
+  MOCK_METHOD1(OnScanResultHandler, void(const std::vector<ScanResult>& scanResult));
+  MOCK_METHOD1(OnErrorHandler, void(OffloadStatus));
+};
+
+} // namespace wificond
+} // namespace android
+
+#endif // WIFICOND_TESTS_MOCK_OFFLOAD_CALLBACK_HANDLERS_H_
+
diff --git a/tests/mock_offload_service_utils.h b/tests/mock_offload_service_utils.h
index eb39108..84bfc21 100644
--- a/tests/mock_offload_service_utils.h
+++ b/tests/mock_offload_service_utils.h
@@ -22,6 +22,7 @@
 
 #include "wificond/scanning/offload/offload_callback.h"
 #include "wificond/scanning/offload/offload_service_utils.h"
+#include "wificond/scanning/offload/offload_callback_handlers.h"
 #include <android/hardware/wifi/offload/1.0/IOffload.h>
 
 using android::hardware::wifi::offload::V1_0::IOffload;
@@ -36,7 +37,7 @@ class MockOffloadServiceUtils : public OffloadServiceUtils {
 
   MOCK_METHOD0(GetOffloadService, sp<IOffload>());
   MOCK_METHOD1(GetOffloadCallback, sp<OffloadCallback>(
-      OnOffloadScanResultsReadyHandler handler));
+      OffloadCallbackHandlers* handlers));
 };
 
 } // namespace wificond
diff --git a/tests/offload_callback_test.cpp b/tests/offload_callback_test.cpp
index e49ff80..f36b5e2 100644
--- a/tests/offload_callback_test.cpp
+++ b/tests/offload_callback_test.cpp
@@ -24,25 +24,29 @@
 #include "wificond/scanning/scan_result.h"
 #include "wificond/scanning/offload/offload_callback.h"
 #include "wificond/tests/offload_test_utils.h"
+#include "wificond/tests/mock_offload_callback_handlers.h"
 
 using android::hardware::wifi::offload::V1_0::ScanResult;
+using android::hardware::wifi::offload::V1_0::OffloadStatus;
 using android::hardware::hidl_vec;
+using testing::NiceMock;
 
 namespace android {
 namespace wificond {
 
 class OffloadCallbackTest: public ::testing::Test {
  protected:
-   virtual void SetUp() {
-     dummy_scan_results_ = OffloadTestUtils::createOffloadScanResults();
-   }
+  virtual void SetUp() {
+    dummy_scan_results_ = OffloadTestUtils::createOffloadScanResults();
+  }
 
-   void TearDown() override {
-     dummy_scan_results_.clear();
-   }
+  void TearDown() override {
+    dummy_scan_results_.clear();
+  }
 
-   std::vector<ScanResult> dummy_scan_results_;
-   std::unique_ptr<OffloadCallback> dut_;
+  std::vector<ScanResult> dummy_scan_results_;
+  std::unique_ptr<OffloadCallback> offload_callback_;
+  std::unique_ptr<NiceMock<MockOffloadCallbackHandlers>> handlers_;
 };
 
 /**
@@ -51,14 +55,33 @@ class OffloadCallbackTest: public ::testing::Test {
  */
 TEST_F(OffloadCallbackTest, checkScanResultSize) {
   std::vector<ScanResult> scan_result;
-  dut_.reset(new OffloadCallback(
-    [&scan_result] (std::vector<ScanResult> scanResult) -> void {
-      scan_result = scanResult;
-    }));
+  handlers_.reset(new NiceMock<MockOffloadCallbackHandlers>());
+  ON_CALL(*handlers_, OnScanResultHandler(testing::_))
+      .WillByDefault(testing::Invoke(
+          [&scan_result] (std::vector<ScanResult> scanResult) -> void {
+            scan_result = scanResult;
+          }));
+  offload_callback_.reset(new OffloadCallback(handlers_.get()));
   hidl_vec<ScanResult> offloadScanResult(dummy_scan_results_);
-  dut_->onScanResult(offloadScanResult);
+  offload_callback_->onScanResult(offloadScanResult);
   EXPECT_EQ(dummy_scan_results_.size(), scan_result.size());
 }
 
+/**
+ * Testing OffloadCallback to invoke the registered error handler
+ */
+TEST_F(OffloadCallbackTest, checkErrorStatus) {
+  OffloadStatus status_;
+  handlers_.reset(new NiceMock<MockOffloadCallbackHandlers>());
+  ON_CALL(*handlers_, OnErrorHandler(testing::_))
+      .WillByDefault(testing::Invoke(
+          [&status_] (OffloadStatus status) -> void {
+            status_ = status;
+          }));
+  offload_callback_.reset(new OffloadCallback(handlers_.get()));
+  offload_callback_->onError(OffloadStatus::OFFLOAD_STATUS_ERROR);
+  EXPECT_EQ(status_, OffloadStatus::OFFLOAD_STATUS_ERROR);
+}
+
 } // namespace wificond
 } // namespace android
diff --git a/tests/offload_scan_manager_test.cpp b/tests/offload_scan_manager_test.cpp
index 9409c12..cfccbc4 100644
--- a/tests/offload_scan_manager_test.cpp
+++ b/tests/offload_scan_manager_test.cpp
@@ -29,9 +29,10 @@
 #include "wificond/scanning/scan_result.h"
 #include "wificond/scanning/offload/offload_callback.h"
 #include "wificond/scanning/offload/offload_scan_manager.h"
+#include "wificond/scanning/offload/offload_callback_handlers.h"
 
 using android::hardware::wifi::offload::V1_0::ScanResult;
-using android::wificond::OnOffloadScanResultsReadyHandler;
+using android::hardware::wifi::offload::V1_0::OffloadStatus;
 using com::android::server::wifi::wificond::NativeScanResult;
 using testing::NiceMock;
 using testing::_;
@@ -39,13 +40,18 @@ using testing::Invoke;
 using android::sp;
 using std::unique_ptr;
 using std::vector;
+using std::bind;
+
+using namespace std::placeholders;
 
 namespace android {
 namespace wificond {
 
-sp<OffloadCallback> CaptureReturnValue(OnOffloadScanResultsReadyHandler handler,
+sp<OffloadCallback> CaptureReturnValue(
+    OffloadCallbackHandlers* handler,
     sp<OffloadCallback>* offload_callback) {
-  *offload_callback = sp<OffloadCallback>(new OffloadCallback(handler));
+  *offload_callback = sp<OffloadCallback>(
+      new OffloadCallback(handler));
   return *offload_callback;
 }
 
@@ -54,7 +60,7 @@ class OffloadScanManagerTest: public ::testing::Test {
     virtual void SetUp() {
       ON_CALL(*mock_offload_service_utils_, GetOffloadCallback(_))
           .WillByDefault(Invoke(bind(CaptureReturnValue,
-              std::placeholders::_1, &offload_callback_)));
+              _1, &offload_callback_)));
     }
 
     void TearDown() override {
@@ -65,15 +71,15 @@ class OffloadScanManagerTest: public ::testing::Test {
     sp<OffloadCallback> offload_callback_;
     unique_ptr<NiceMock<MockOffloadServiceUtils>> mock_offload_service_utils_{
         new NiceMock<MockOffloadServiceUtils>()};
-    unique_ptr<OffloadScanManager> dut_;
+    unique_ptr<OffloadScanManager> offload_scan_manager_;
 };
 
 /**
  * Testing OffloadScanManager with OffloadServiceUtils null argument
  */
 TEST_F(OffloadScanManagerTest, ServiceUtilsNotAvailableTest) {
-  dut_.reset(new OffloadScanManager(nullptr, nullptr));
-  EXPECT_EQ(false, dut_->isServiceAvailable());
+  offload_scan_manager_.reset(new OffloadScanManager(nullptr, nullptr));
+  EXPECT_EQ(OffloadScanManager::kError, offload_scan_manager_->getOffloadStatus());
 }
 
 /**
@@ -83,9 +89,9 @@ TEST_F(OffloadScanManagerTest, ServiceUtilsNotAvailableTest) {
 TEST_F(OffloadScanManagerTest, ServiceNotAvailableTest) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(nullptr));
-  dut_.reset(new OffloadScanManager(mock_offload_service_utils_.get(),
-      nullptr));
-  EXPECT_EQ(false, dut_->isServiceAvailable());
+  offload_scan_manager_.reset(new OffloadScanManager(mock_offload_service_utils_.get(),
+      [] (std::vector<NativeScanResult> scanResult) -> void {}));
+  EXPECT_EQ(OffloadScanManager::kNoService, offload_scan_manager_->getOffloadStatus());
 }
 
 /**
@@ -96,9 +102,9 @@ TEST_F(OffloadScanManagerTest, ServiceAvailableTest) {
   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
-  dut_ .reset(new OffloadScanManager(mock_offload_service_utils_.get(),
+  offload_scan_manager_ .reset(new OffloadScanManager(mock_offload_service_utils_.get(),
     [] (vector<NativeScanResult> scanResult) -> void {}));
-  EXPECT_EQ(true, dut_->isServiceAvailable());
+  EXPECT_EQ(OffloadScanManager::kNoError, offload_scan_manager_->getOffloadStatus());
 }
 
 /**
@@ -111,7 +117,7 @@ TEST_F(OffloadScanManagerTest, CallbackInvokedTest) {
   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
-  dut_.reset(new OffloadScanManager(mock_offload_service_utils_.get(),
+  offload_scan_manager_.reset(new OffloadScanManager(mock_offload_service_utils_.get(),
     [&callback_invoked] (vector<NativeScanResult> scanResult) -> void {
         callback_invoked = true;
     }));
@@ -120,5 +126,19 @@ TEST_F(OffloadScanManagerTest, CallbackInvokedTest) {
   EXPECT_EQ(true, callback_invoked);
 }
 
-} // wificond
-} //android
+/**
+ * Testing OffloadScanManager when service is available and valid handler
+ * is registered, ensure that error callback is invoked
+ */
+TEST_F(OffloadScanManagerTest, ErrorCallbackInvokedTest) {
+  EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
+  ON_CALL(*mock_offload_service_utils_, GetOffloadService())
+      .WillByDefault(testing::Return(mock_offload_));
+  offload_scan_manager_.reset(new OffloadScanManager(mock_offload_service_utils_.get(),
+    [this] (std::vector<NativeScanResult> scanResult) -> void {}));
+  offload_callback_->onError(OffloadStatus::OFFLOAD_STATUS_ERROR);
+  EXPECT_EQ(offload_scan_manager_->getOffloadStatus(), OffloadScanManager::kError);
+}
+
+} // namespace wificond
+} // namespace android