Home | History | Annotate | Download | only in tests 
      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 <android-base/logging.h>
     20 #include <gtest/gtest.h>
     21 #include "wificond/scanning/offload/offload_scan_utils.h"
     22 #include "wificond/scanning/scan_result.h"
     23 #include "wificond/tests/offload_hal_test_constants.h"
     24 #include "wificond/tests/offload_test_utils.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 { dummy_scan_results_.clear(); }
     48 
     49   vector<ScanResult> dummy_scan_results_;
     50 };
     51 
     52 TEST_F(OffloadScanUtilsTest, verifyConversion) {
     53   vector<NativeScanResult> native_scan_results;
     54   EXPECT_TRUE(OffloadScanUtils::convertToNativeScanResults(
     55       dummy_scan_results_, &native_scan_results));
     56   EXPECT_EQ(native_scan_results.size(), dummy_scan_results_.size());
     57   for (size_t i = 0; i < native_scan_results.size(); i++) {
     58     EXPECT_EQ(native_scan_results[i].frequency,
     59               dummy_scan_results_[i].frequency);
     60     EXPECT_EQ(native_scan_results[i].signal_mbm, dummy_scan_results_[i].rssi);
     61     EXPECT_EQ(native_scan_results[i].ssid.size(),
     62               dummy_scan_results_[i].networkInfo.ssid.size());
     63     EXPECT_EQ(native_scan_results[i].bssid.size(),
     64               dummy_scan_results_[i].bssid.elementCount());
     65     EXPECT_EQ(native_scan_results[i].capability,
     66               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(
     74       scan_ssids, frequencies, 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(
     93       match_ssids, 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 =
    110       OffloadTestUtils::createScanStats(&stats_expected);
    111   NativeScanStats stats_returned =
    112       OffloadScanUtils::convertToNativeScanStats(offload_scan_stats);
    113   EXPECT_TRUE(stats_expected == stats_returned);
    114 }
    115 
    116 }  // namespace wificond
    117 }  // namespace android
    118