device_google_wahoo/wifi_offload/test/offload_hal_test_utils.cpp

/*
 * 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 "offload_hal_test_utils.h"

namespace android {
namespace hardware {
namespace wifi {
namespace offload {
namespace V1_0 {
namespace implementation {
namespace offload_hal_test_utils {

using namespace offload_hal_test_constants;

void createChreScanResultsForTest(std::vector<wifi_offload::ScanResult>* chreScanResults) {
    wifi_offload::ScanResult chreScanResult;
    chreScanResult.security_modes_ = kNetworkFlags;
    chreScanResult.capability_ = kCapability;
    chreScanResult.frequency_scanned_mhz_ = kFrequency1;
    chreScanResult.rssi_dbm_ = kRssi;
    chreScanResult.tsf_ = kTsf;
    chreScanResult.ssid_.SetData(&kSsid1[0], kSsid1_size);
    memcpy(&chreScanResult.bssid_[0], &kBssid[0], kBssidSize);
    chreScanResults->push_back(chreScanResult);
}

void createChreScanStatsForTest(wifi_offload::ScanStats* chreScanStats) {
    chreScanStats->num_scans_requested_by_nanoapp_ = kDefaultNumScansRequestedByWifi;
    chreScanStats->num_scans_serviced_by_hardware_ = kDefaultNumScansServicedByWifi;
    chreScanStats->num_scans_serviced_by_cache_ =
        (kDefaultNumScansRequestedByWifi - kDefaultNumScansServicedByWifi);
    for (size_t j = 0; j < kNumChannelsScanned[0] + kNumChannelsScanned[1]; j++) {
        chreScanStats->channel_histogram_.IncrementScanCountForChannelForTest(
            kTestChannels[j], static_cast<uint32_t>(kNumTimesChannelScanned[j]));
    }
    chreScanStats->last_subscription_duration_ms_ = kSubscriptionDurationMs;
    wifi_offload::ScanRecord scanRecord1;
    scanRecord1.time_spent_scanning_ms_ = kScanDurationMs[0];
    scanRecord1.num_channels_scanned_ = kNumChannelsScanned[0];
    scanRecord1.num_entries_aggregated_ = 1;
    chreScanStats->scan_records_.push_back(scanRecord1);
    wifi_offload::ScanRecord scanRecord2;
    scanRecord2.time_spent_scanning_ms_ = kScanDurationMs[1];
    scanRecord2.num_channels_scanned_ = kNumChannelsScanned[1];
    scanRecord2.num_entries_aggregated_ = 1;
    chreScanStats->scan_records_.push_back(scanRecord2);

    for (size_t i = 0; i < kRecordLength; i++) {
        wifi_offload::RpcLogRecord logRecord;
        logRecord.record_type_ = kChreRecordTypeList[i];
        logRecord.timestamp_chre_ms_ = kSystemStartTime + i * kIncrementBetweenEvents;
        chreScanStats->rpc_log_records_.push_back(logRecord);
    }
}

void createHidlScanFilterForTest(ScanFilter* scanFilter) {
    std::vector<NetworkInfo> nw_info_list;
    NetworkInfo nwInfo1;
    std::vector<uint8_t> ssid1(kSsid1, kSsid1 + kSsid1_size);
    nwInfo1.ssid = ssid1;
    nwInfo1.flags = kNetworkFlags;
    NetworkInfo nwInfo2;
    std::vector<uint8_t> ssid2(kSsid2, kSsid2 + kSsid2_size);
    nwInfo2.ssid = ssid2;
    nwInfo2.flags = kNetworkFlags;
    nw_info_list.push_back(nwInfo1);
    nw_info_list.push_back(nwInfo2);
    scanFilter->preferredNetworkInfoList = nw_info_list;
    scanFilter->rssiThreshold = kRssiThreshold;
}

void createHidlScanParamForTest(ScanParam* scanParam) {
    scanParam->disconnectedModeScanIntervalMs = kDisconnectedModeScanIntervalMs;
    std::vector<uint32_t> frequencyList{kFrequency1, kFrequency2};
    scanParam->frequencyList = frequencyList;
    std::vector<hidl_vec<uint8_t>> ssidList;
    std::vector<uint8_t> ssid1(kSsid1, kSsid1 + kSsid1_size);
    std::vector<uint8_t> ssid2(kSsid2, kSsid2 + kSsid2_size);
    ssidList.push_back(ssid1);
    ssidList.push_back(ssid2);
    scanParam->ssidList = ssidList;
}

void createChreScanConfigForTest(wifi_offload::ScanConfig* scanConfig) {
    scanConfig->scan_params_.disconnected_mode_scan_interval_ms_ = kDisconnectedModeScanIntervalMs;
    wifi_offload::Ssid chreSsid1;
    chreSsid1.SetData(&kSsid1[0], kSsid1_size);
    wifi_offload::Ssid chreSsid2;
    chreSsid2.SetData(&kSsid2[0], kSsid2_size);
    scanConfig->scan_params_.ssids_to_scan_.push_back(chreSsid1);
    scanConfig->scan_params_.ssids_to_scan_.push_back(chreSsid2);
    scanConfig->scan_params_.frequencies_to_scan_mhz_.push_back(kFrequency1);
    scanConfig->scan_params_.frequencies_to_scan_mhz_.push_back(kFrequency2);
    scanConfig->scan_filter_.min_rssi_threshold_dbm_ = kRssiThreshold;
    wifi_offload::PreferredNetwork chreNwInfo1;
    chreNwInfo1.security_modes_ = kNetworkFlags;
    chreNwInfo1.ssid_.SetData(&kSsid1[0], kSsid1_size);
    scanConfig->scan_filter_.networks_to_match_.push_back(std::move(chreNwInfo1));
    wifi_offload::PreferredNetwork chreNwInfo2;
    chreNwInfo2.security_modes_ = kNetworkFlags;
    chreNwInfo2.ssid_.SetData(&kSsid2[0], kSsid2_size);
    scanConfig->scan_filter_.networks_to_match_.push_back(std::move(chreNwInfo2));
}

bool validateScanResult(const std::vector<ScanResult>& hidlScanResultsTest,
                        const std::vector<wifi_offload::ScanResult> chreScanResults) {
    if (hidlScanResultsTest.size() != chreScanResults.size())
        return false;
    uint32_t i = 0;
    for (const auto& hidlScanResult : hidlScanResultsTest) {
        if (hidlScanResult.tsf != chreScanResults[i].tsf_)
            return false;
        if (hidlScanResult.rssi != chreScanResults[i].rssi_dbm_)
            return false;
        if (hidlScanResult.capability != chreScanResults[i].capability_)
            return false;
        if (hidlScanResult.frequency != chreScanResults[i].frequency_scanned_mhz_)
            return false;
        for (int j = 0; j < kBssidSize; j++) {
            if (hidlScanResult.bssid[j] != chreScanResults[i].bssid_[j])
                return false;
        }
        chreWifiSsidListItem chreWifiSsid;
        chreScanResults[i].ssid_.ToChreWifiSsidListItem(&chreWifiSsid);
        for (size_t k = 0; k < chreWifiSsid.ssidLen; k++) {
            if (hidlScanResult.networkInfo.ssid[k] != chreWifiSsid.ssid[k])
                return false;
        }
        if (hidlScanResult.networkInfo.flags != kNetworkFlags) {
            return false;
        }
        i++;
    }
    return true;
}

bool validateScanStats(const ScanStats& hidlScanStats,
                       const wifi_offload::ScanStats& chreScanStats) {
    if (hidlScanStats.subscriptionDurationMs != chreScanStats.last_subscription_duration_ms_)
        return false;
    if (hidlScanStats.numScansRequestedByWifi != chreScanStats.num_scans_requested_by_nanoapp_)
        return false;
    if (hidlScanStats.numScansServicedByWifi != chreScanStats.num_scans_serviced_by_hardware_)
        return false;
    if (hidlScanStats.numScansServicedbyCache != chreScanStats.num_scans_serviced_by_cache_)
        return false;
    for (uint32_t i = 0; i < kNumChannelsInHistogram; i++) {
        if (hidlScanStats.histogramChannelsScanned[i] !=
            chreScanStats.channel_histogram_.GetChannelScanCount(i)) {
            return false;
        }
    }
    if (hidlScanStats.scanRecord.size() != chreScanStats.scan_records_.size())
        return false;
    uint32_t i = 0;
    for (const auto& scanRecord : hidlScanStats.scanRecord) {
        if (scanRecord.durationMs != chreScanStats.scan_records_[i].time_spent_scanning_ms_)
            return false;
        if (scanRecord.numChannelsScanned != chreScanStats.scan_records_[i].num_channels_scanned_)
            return false;
        if (scanRecord.numEntriesAggregated !=
            chreScanStats.scan_records_[i].num_entries_aggregated_)
            return false;
        i++;
    }
    if (hidlScanStats.logRecord.size() != chreScanStats.rpc_log_records_.size())
        return false;
    i = 0;

    for (const auto& logRecord : hidlScanStats.logRecord) {
        if (logRecord.recordName != kHidlRecordNameList[i]) {
            return false;
        }
        if (logRecord.logTimeMs != chreScanStats.rpc_log_records_[i].timestamp_chre_ms_)
            return false;
        i++;
    }
    return true;
}

}  // namespace offload_hal_test_utils
}  // namespace implementation
}  // namespace V1_0
}  // namespace offload
}  // namespace wifi
}  // namespace hardware
}  // namespace android