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 <vector>
  20 #include <string>
  21
  22 #include <gtest/gtest.h>
  23 #include <android/hardware/wifi/offload/1.0/IOffload.h>
  24
  25 #include "wificond/tests/mock_offload.h"
  26 #include "wificond/tests/mock_offload_service_utils.h"
  27 #include "wificond/tests/offload_test_utils.h"
  28
  29 #include "wificond/scanning/scan_result.h"
  30 #include "wificond/scanning/offload/offload_callback.h"
  31 #include "wificond/scanning/offload/offload_scan_manager.h"
  32 #include "wificond/scanning/offload/offload_callback_handlers.h"
  33
  34 using android::hardware::wifi::offload::V1_0::ScanResult;
  35 using android::hardware::wifi::offload::V1_0::OffloadStatus;
  36 using android::hardware::wifi::offload::V1_0::ScanParam;
  37 using android::hardware::wifi::offload::V1_0::ScanFilter;
  38 using com::android::server::wifi::wificond::NativeScanResult;
  39 using testing::NiceMock;
  40 using testing::_;
  41 using testing::Invoke;
  42 using android::sp;
  43 using std::unique_ptr;
  44 using std::vector;
  45 using std::bind;
  46
  47 using namespace std::placeholders;
  48
  49 namespace android {
  50 namespace wificond {
  51
  52 sp<OffloadCallback> CaptureReturnValue(
  53     OffloadCallbackHandlers* handler,
  54     sp<OffloadCallback>* offload_callback) {
  55   *offload_callback = sp<OffloadCallback>(
  56       new OffloadCallback(handler));
  57   return *offload_callback;
  58 }
  59
  60 class OffloadScanManagerTest: public ::testing::Test {
  61   protected:
  62     virtual void SetUp() {
  63       ON_CALL(*mock_offload_service_utils_, GetOffloadCallback(_))
  64           .WillByDefault(Invoke(bind(CaptureReturnValue,
  65               _1, &offload_callback_)));
  66     }
  67
  68     void TearDown() override {
  69       offload_callback_.clear();
  70     }
  71
  72     sp<NiceMock<MockOffload>> mock_offload_{new NiceMock<MockOffload>()};
  73     sp<OffloadCallback> offload_callback_;
  74     unique_ptr<NiceMock<MockOffloadServiceUtils>> mock_offload_service_utils_{
  75         new NiceMock<MockOffloadServiceUtils>()};
  76     unique_ptr<OffloadScanManager> offload_scan_manager_;
  77 };
  78
  79 /**
  80  * Testing OffloadScanManager with OffloadServiceUtils null argument
  81  */
  82 TEST_F(OffloadScanManagerTest, ServiceUtilsNotAvailableTest) {
  83   offload_scan_manager_.reset(new OffloadScanManager(nullptr, nullptr));
  84   EXPECT_EQ(OffloadScanManager::kError,
  85       offload_scan_manager_->getOffloadStatus());
  86 }
  87
  88 /**
  89  * Testing OffloadScanManager with no handle on Offloal HAL service
  90  * and no registered handler for Offload Scan results
  91  */
  92 TEST_F(OffloadScanManagerTest, ServiceNotAvailableTest) {
  93   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
  94       .WillByDefault(testing::Return(nullptr));
  95   offload_scan_manager_.reset(new OffloadScanManager(
  96       mock_offload_service_utils_.get(),
  97       [] (vector<NativeScanResult> scanResult) -> void {}));
  98   EXPECT_EQ(OffloadScanManager::kNoService,
  99       offload_scan_manager_->getOffloadStatus());
 100 }
 101
 102 /**
 103  * Testing OffloadScanManager when service is available and valid handler
 104  * registered for Offload Scan results
 105  */
 106 TEST_F(OffloadScanManagerTest, ServiceAvailableTest) {
 107   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 108   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 109       .WillByDefault(testing::Return(mock_offload_));
 110   offload_scan_manager_ .reset(new OffloadScanManager(
 111       mock_offload_service_utils_.get(),
 112       [] (vector<NativeScanResult> scanResult) -> void {}));
 113   EXPECT_EQ(OffloadScanManager::kNoError,
 114       offload_scan_manager_->getOffloadStatus());
 115 }
 116
 117 /**
 118  * Testing OffloadScanManager when service is available and valid handler
 119  * is registered, test to ensure that registered handler is invoked when
 120  * scan results are available
 121  */
 122 TEST_F(OffloadScanManagerTest, CallbackInvokedTest) {
 123   bool callback_invoked = false;
 124   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 125   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 126       .WillByDefault(testing::Return(mock_offload_));
 127   offload_scan_manager_.reset(new OffloadScanManager(
 128       mock_offload_service_utils_.get(),
 129       [&callback_invoked] (vector<NativeScanResult> scanResult) -> void {
 130         callback_invoked = true;
 131       }));
 132   vector<ScanResult> dummy_scan_results_ =
 133       OffloadTestUtils::createOffloadScanResults();
 134   offload_callback_->onScanResult(dummy_scan_results_);
 135   EXPECT_EQ(true, callback_invoked);
 136 }
 137
 138 /**
 139  * Testing OffloadScanManager when service is available and valid handler
 140  * is registered, ensure that error callback is invoked
 141  */
 142 TEST_F(OffloadScanManagerTest, ErrorCallbackInvokedTest) {
 143   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 144   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 145       .WillByDefault(testing::Return(mock_offload_));
 146   offload_scan_manager_.reset(new OffloadScanManager(
 147       mock_offload_service_utils_.get(),
 148       [this] (vector<NativeScanResult> scanResult) -> void {}));
 149   offload_callback_->onError(OffloadStatus::OFFLOAD_STATUS_ERROR);
 150   EXPECT_EQ(offload_scan_manager_->getOffloadStatus(),
 151       OffloadScanManager::kError);
 152 }
 153
 154 /**
 155  * Testing OffloadScanManager for subscribing to the scan results from
 156  * Offload HAL when service is running without errors
 157  */
 158 TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsOk) {
 159   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 160   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 161       .WillByDefault(testing::Return(mock_offload_));
 162   offload_scan_manager_ .reset(new OffloadScanManager(
 163       mock_offload_service_utils_.get(),
 164       [] (vector<NativeScanResult> scanResult) -> void {}));
 165   EXPECT_CALL(*mock_offload_, subscribeScanResults(_));
 166   EXPECT_CALL(*mock_offload_, configureScans(_, _));
 167   vector<vector<uint8_t>> scan_ssids { kSsid1, kSsid2};
 168   vector<vector<uint8_t>> match_ssids { kSsid1, kSsid2 };
 169   vector<uint8_t> security_flags { kNetworkFlags, kNetworkFlags };
 170   vector<uint32_t> frequencies { kFrequency1, kFrequency2 };
 171   OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
 172   bool result = offload_scan_manager_->startScan(kDisconnectedModeScanIntervalMs,
 173       kRssiThreshold,
 174       scan_ssids,
 175       match_ssids,
 176       security_flags,
 177       frequencies,
 178       &reason_code);
 179   EXPECT_EQ(result, true);
 180 }
 181
 182 /**
 183  * Testing OffloadScanManager for subscribing to the scan results from
 184  * Offload HAL when service is not available
 185  */
 186 TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsNotAvailable) {
 187   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 188   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 189       .WillByDefault(testing::Return(nullptr));
 190   offload_scan_manager_ .reset(new OffloadScanManager(
 191       mock_offload_service_utils_.get(),
 192       [] (vector<NativeScanResult> scanResult) -> void {}));
 193   vector<vector<uint8_t>> scan_ssids { kSsid1, kSsid2};
 194   vector<vector<uint8_t>> match_ssids { kSsid1, kSsid2 };
 195   vector<uint8_t> security_flags { kNetworkFlags, kNetworkFlags };
 196   vector<uint32_t> frequencies { kFrequency1, kFrequency2 };
 197   OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
 198   bool result = offload_scan_manager_->startScan(kDisconnectedModeScanIntervalMs,
 199       kRssiThreshold,
 200       scan_ssids,
 201       match_ssids,
 202       security_flags,
 203       frequencies,
 204       &reason_code);
 205   EXPECT_EQ(result, false);
 206   EXPECT_EQ(reason_code, OffloadScanManager::kNotSupported);
 207 }
 208
 209 /**
 210  * Testing OffloadScanManager for subscribing to the scan results from
 211  * Offload HAL when service is not working correctly
 212  */
 213 TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsNotConnected) {
 214   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 215   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 216       .WillByDefault(testing::Return(mock_offload_));
 217   offload_scan_manager_ .reset(new OffloadScanManager(
 218       mock_offload_service_utils_.get(),
 219       [] (vector<NativeScanResult> scanResult) -> void {}));
 220   vector<vector<uint8_t>> scan_ssids { kSsid1, kSsid2};
 221   vector<vector<uint8_t>> match_ssids { kSsid1, kSsid2 };
 222   vector<uint8_t> security_flags { kNetworkFlags, kNetworkFlags };
 223   vector<uint32_t> frequencies { kFrequency1, kFrequency2 };
 224   offload_callback_->onError(OffloadStatus::OFFLOAD_STATUS_NO_CONNECTION);
 225   OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
 226   bool result = offload_scan_manager_->startScan(kDisconnectedModeScanIntervalMs,
 227       kRssiThreshold,
 228       scan_ssids,
 229       match_ssids,
 230       security_flags,
 231       frequencies,
 232       &reason_code);
 233   EXPECT_EQ(result, false);
 234   EXPECT_EQ(reason_code, OffloadScanManager::kNotAvailable);
 235 }
 236
 237 /**
 238  * Testing OffloadScanManager for subscribing to the scan results from
 239  * Offload HAL twice when service is okay
 240  */
 241 TEST_F(OffloadScanManagerTest, StartScanTwiceTestWhenServiceIsOk) {
 242   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 243   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 244       .WillByDefault(testing::Return(mock_offload_));
 245   offload_scan_manager_ .reset(new OffloadScanManager(
 246       mock_offload_service_utils_.get(),
 247       [] (vector<NativeScanResult> scanResult) -> void {}));
 248   EXPECT_CALL(*mock_offload_, subscribeScanResults(_)).Times(1);
 249   EXPECT_CALL(*mock_offload_, configureScans(_, _)).Times(2);
 250   vector<vector<uint8_t>> scan_ssids { kSsid1, kSsid2};
 251   vector<vector<uint8_t>> match_ssids { kSsid1, kSsid2 };
 252   vector<uint8_t> security_flags { kNetworkFlags, kNetworkFlags };
 253   vector<uint32_t> frequencies { kFrequency1, kFrequency2 };
 254   OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
 255   bool result = offload_scan_manager_->startScan(kDisconnectedModeScanIntervalMs,
 256       kRssiThreshold,
 257       scan_ssids,
 258       match_ssids,
 259       security_flags,
 260       frequencies,
 261       &reason_code);
 262   EXPECT_EQ(result, true);
 263   result = offload_scan_manager_->startScan(kDisconnectedModeScanIntervalMs,
 264       kRssiThreshold,
 265       scan_ssids,
 266       match_ssids,
 267       security_flags,
 268       frequencies,
 269       &reason_code);
 270   EXPECT_EQ(result, true);
 271 }
 272
 273 /**
 274  * Testing OffloadScanManager for unsubscribing to the scan results from
 275  * Offload HAL when service is ok
 276  */
 277 TEST_F(OffloadScanManagerTest, StopScanTestWhenServiceIsOk) {
 278   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 279   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 280       .WillByDefault(testing::Return(mock_offload_));
 281   offload_scan_manager_ .reset(new OffloadScanManager(
 282       mock_offload_service_utils_.get(),
 283       [] (vector<NativeScanResult> scanResult) -> void {}));
 284   EXPECT_CALL(*mock_offload_, subscribeScanResults(_));
 285   EXPECT_CALL(*mock_offload_, configureScans(_, _));
 286   EXPECT_CALL(*mock_offload_, unsubscribeScanResults());
 287   vector<vector<uint8_t>> scan_ssids { kSsid1, kSsid2};
 288   vector<vector<uint8_t>> match_ssids { kSsid1, kSsid2 };
 289   vector<uint8_t> security_flags { kNetworkFlags, kNetworkFlags };
 290   vector<uint32_t> frequencies { kFrequency1, kFrequency2 };
 291   OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
 292   bool result = offload_scan_manager_->startScan(kDisconnectedModeScanIntervalMs,
 293       kRssiThreshold,
 294       scan_ssids,
 295       match_ssids,
 296       security_flags,
 297       frequencies,
 298       &reason_code);
 299   EXPECT_EQ(result, true);
 300   result = offload_scan_manager_->stopScan(&reason_code);
 301   EXPECT_EQ(result, true);
 302 }
 303
 304 /**
 305  * Testing OffloadScanManager for unsubscribing to the scan results from
 306  * Offload HAL without first subscribing
 307  */
 308 TEST_F(OffloadScanManagerTest, StopScanTestWithoutStartWhenServiceIsOk) {
 309   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 310   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 311       .WillByDefault(testing::Return(mock_offload_));
 312   offload_scan_manager_ .reset(new OffloadScanManager(
 313       mock_offload_service_utils_.get(),
 314       [] (vector<NativeScanResult> scanResult) -> void {}));
 315   OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
 316   bool result = offload_scan_manager_->stopScan(&reason_code);
 317   EXPECT_EQ(result, false);
 318   EXPECT_EQ(reason_code, OffloadScanManager::kNotSubscribed);
 319 }
 320
 321 /**
 322  * Testing OffloadScanManager for unsubscribing to the scan results from
 323  * Offload HAL without first subscribing when service is not working correctly
 324  */
 325 TEST_F(OffloadScanManagerTest, StopScanTestWhenServiceIsNotConnectedAnymore) {
 326   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
 327   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
 328       .WillByDefault(testing::Return(mock_offload_));
 329   offload_scan_manager_ .reset(new OffloadScanManager(
 330       mock_offload_service_utils_.get(),
 331       [] (vector<NativeScanResult> scanResult) -> void {}));
 332   EXPECT_CALL(*mock_offload_, subscribeScanResults(_));
 333   EXPECT_CALL(*mock_offload_, configureScans(_, _));
 334   EXPECT_CALL(*mock_offload_, unsubscribeScanResults());
 335   vector<vector<uint8_t>> scan_ssids { kSsid1, kSsid2};
 336   vector<vector<uint8_t>> match_ssids { kSsid1, kSsid2 };
 337   vector<uint8_t> security_flags { kNetworkFlags, kNetworkFlags };
 338   vector<uint32_t> frequencies { kFrequency1, kFrequency2 };
 339   OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
 340   bool result = offload_scan_manager_->startScan(kDisconnectedModeScanIntervalMs,
 341       kRssiThreshold,
 342       scan_ssids,
 343       match_ssids,
 344       security_flags,
 345       frequencies,
 346       &reason_code);
 347   EXPECT_EQ(result, true);
 348   offload_callback_->onError(OffloadStatus::OFFLOAD_STATUS_NO_CONNECTION);
 349   result = offload_scan_manager_->stopScan(&reason_code);
 350   EXPECT_EQ(result, true);
 351 }
 352
 353 }
 354 }
 355