/*
* 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