tests/offload_scan_utils_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 <vector>
  18
  19 #include <gtest/gtest.h>
  20 #include "wificond/tests/offload_test_utils.h"
  21 #include <android-base/logging.h>
  22 #include "wificond/scanning/scan_result.h"
  23 #include "wificond/scanning/offload/offload_scan_utils.h"
  24 #include "wificond/tests/offload_hal_test_constants.h"
  25
  26 using android::hardware::wifi::offload::V1_0::ScanResult;
  27 using android::hardware::wifi::offload::V1_0::ScanParam;
  28 using android::hardware::wifi::offload::V1_0::ScanFilter;
  29 using android::hardware::wifi::offload::V1_0::NetworkInfo;
  30 using android::hardware::wifi::offload::V1_0::ScanRecord;
  31 using android::hardware::wifi::offload::V1_0::ScanStats;
  32 using ::com::android::server::wifi::wificond::NativeScanResult;
  33 using ::com::android::server::wifi::wificond::NativeScanStats;
  34 using std::vector;
  35
  36 using namespace android::wificond::offload_hal_test_constants;
  37
  38 namespace android {
  39 namespace wificond {
  40
  41 class OffloadScanUtilsTest : public ::testing::Test {
  42  protected:
  43   virtual void SetUp() {
  44     dummy_scan_results_ = OffloadTestUtils::createOffloadScanResults();
  45   }
  46
  47   void TearDown() override {
  48     dummy_scan_results_.clear();
  49   }
  50
  51   vector<ScanResult> dummy_scan_results_;
  52 };
  53
  54 TEST_F(OffloadScanUtilsTest, verifyConversion) {
  55   vector<NativeScanResult> native_scan_results =
  56       OffloadScanUtils::convertToNativeScanResults(dummy_scan_results_);
  57   EXPECT_EQ(native_scan_results.size(), dummy_scan_results_.size());
  58   for (size_t i = 0; i < native_scan_results.size(); i++) {
  59     EXPECT_EQ(native_scan_results[i].frequency, dummy_scan_results_[i].frequency);
  60     EXPECT_EQ(native_scan_results[i].tsf, dummy_scan_results_[i].tsf);
  61     EXPECT_EQ(native_scan_results[i].signal_mbm, dummy_scan_results_[i].rssi);
  62     EXPECT_EQ(native_scan_results[i].ssid.size(),
  63         dummy_scan_results_[i].networkInfo.ssid.size());
  64     EXPECT_EQ(native_scan_results[i].bssid.size(),
  65         dummy_scan_results_[i].bssid.elementCount());
  66     EXPECT_EQ(native_scan_results[i].capability, dummy_scan_results_[i].capability);
  67   }
  68 }
  69
  70 TEST_F(OffloadScanUtilsTest, verifyScanParam) {
  71   vector<vector<uint8_t>> scan_ssids { kSsid1, kSsid2};
  72   vector<uint32_t> frequencies { kFrequency1, kFrequency2 };
  73   ScanParam scanParam = OffloadScanUtils::createScanParam(scan_ssids, frequencies,
  74       kDisconnectedModeScanIntervalMs);
  75   EXPECT_EQ(scanParam.disconnectedModeScanIntervalMs,
  76       kDisconnectedModeScanIntervalMs);
  77   for (size_t i = 0; i < frequencies.size(); i++) {
  78     EXPECT_EQ(scanParam.frequencyList[i], frequencies[i]);
  79   }
  80   for (size_t j = 0; j < scan_ssids.size(); j++) {
  81     vector<uint8_t> ssid_result = scanParam.ssidList[j];
  82     vector<uint8_t> ssid_input = scan_ssids[j];
  83     for (size_t k = 0; k < ssid_result.size(); k++) {
  84       EXPECT_EQ(ssid_result[k], ssid_input[k]);
  85     }
  86   }
  87 }
  88
  89 TEST_F(OffloadScanUtilsTest, verifyScanFilter) {
  90   vector<vector<uint8_t>> match_ssids { kSsid1, kSsid2 };
  91   vector<uint8_t> security_flags { kNetworkFlags, kNetworkFlags };
  92   ScanFilter scanFilter = OffloadScanUtils::createScanFilter(match_ssids,
  93       security_flags, kRssiThreshold);
  94   EXPECT_EQ(kRssiThreshold, scanFilter.rssiThreshold);
  95   EXPECT_FALSE(scanFilter.preferredNetworkInfoList.size() == 0);
  96   for (size_t i = 0; i < security_flags.size(); ++i) {
  97     NetworkInfo nwInfo = scanFilter.preferredNetworkInfoList[i];
  98     vector<uint8_t> ssid = nwInfo.ssid;
  99     vector<uint8_t> match_ssid = match_ssids[i];
 100     EXPECT_EQ(nwInfo.flags, security_flags[i]);
 101     for (size_t j = 0; j < ssid.size(); j++) {
 102       EXPECT_EQ(ssid[j], match_ssid[j]);
 103     }
 104   }
 105 }
 106
 107 TEST_F(OffloadScanUtilsTest, verifyScanStats) {
 108   NativeScanStats stats_expected;
 109   ScanStats offload_scan_stats = OffloadTestUtils::createScanStats(&stats_expected);
 110   NativeScanStats stats_returned = OffloadScanUtils::convertToNativeScanStats(
 111     offload_scan_stats);
 112   EXPECT_TRUE(stats_expected == stats_returned);
 113 }
 114
 115 } // namespace wificond
 116 } // namespace android