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 #define LOG_TAG "wifi_offload_hidl_hal_test" 18 19 #include <android-base/logging.h> 20 #include <android/hardware/wifi/offload/1.0/IOffload.h> 21 #include <android/hardware/wifi/offload/1.0/IOffloadCallback.h> 22 #include <android/hardware/wifi/offload/1.0/types.h> 23 24 #include <VtsHalHidlTargetCallbackBase.h> 25 #include <VtsHalHidlTargetTestBase.h> 26 #include <VtsHalHidlTargetTestEnvBase.h> 27 28 #include <vector> 29 30 #include "hidl_call_util.h" 31 32 using ::android::hardware::wifi::offload::V1_0::IOffload; 33 using ::android::hardware::wifi::offload::V1_0::IOffloadCallback; 34 using ::android::hardware::wifi::offload::V1_0::ScanResult; 35 using ::android::hardware::wifi::offload::V1_0::ScanParam; 36 using ::android::hardware::wifi::offload::V1_0::Ssid; 37 using ::android::hardware::wifi::offload::V1_0::NetworkInfo; 38 using ::android::hardware::wifi::offload::V1_0::ScanFilter; 39 using ::android::hardware::wifi::offload::V1_0::ScanStats; 40 using ::android::hardware::wifi::offload::V1_0::OffloadStatus; 41 using ::android::hardware::wifi::offload::V1_0::OffloadStatusCode; 42 using ::android::hardware::Return; 43 using ::android::hardware::Void; 44 using ::android::hardware::hidl_vec; 45 using ::android::sp; 46 47 constexpr char kOffloadCallbackSendScanResult[] = "onScanResult"; 48 constexpr char kOffloadCallbackSendError[] = "onError"; 49 50 namespace { 51 const uint8_t kSsid1[] = {'G', 'o', 'o', 'g', 'l', 'e'}; 52 const uint8_t kSsid2[] = {'X', 'f', 'i', 'n', 'i', 't', 'y'}; 53 const uint8_t kBssid[6] = {0x12, 0xef, 0xa1, 0x2c, 0x97, 0x8b}; 54 const int16_t kRssi = -60; 55 const uint32_t kFrequency = 2412; 56 const uint8_t kBssidSize = 6; 57 const uint64_t kTsf = 0; 58 const uint16_t kCapability = 0; 59 const uint8_t kNetworkFlags = 0; 60 const uint32_t kFrequency1 = 2412; 61 const uint32_t kFrequency2 = 2437; 62 const uint32_t kDisconnectedModeScanIntervalMs = 5000; 63 const int16_t kRssiThreshold = -76; 64 } 65 66 class OffloadCallbackArgs { 67 public: 68 hidl_vec<ScanResult> scan_results_; 69 OffloadStatus error_code_; 70 }; 71 72 // Test environment for Weaver HIDL HAL. 73 class WifiOffloadHidlEnvironment 74 : public ::testing::VtsHalHidlTargetTestEnvBase { 75 public: 76 // get the test environment singleton 77 static WifiOffloadHidlEnvironment* Instance() { 78 static WifiOffloadHidlEnvironment* instance = 79 new WifiOffloadHidlEnvironment; 80 return instance; 81 } 82 83 virtual void registerTestServices() override { 84 registerTestService<IOffload>(); 85 } 86 87 private: 88 WifiOffloadHidlEnvironment() {} 89 }; 90 91 // The main test class for WifiOffload HIDL HAL. 92 class WifiOffloadHidlTest : public ::testing::VtsHalHidlTargetTestBase { 93 public: 94 virtual void SetUp() override { 95 wifi_offload_ = 96 ::testing::VtsHalHidlTargetTestBase::getService<IOffload>( 97 WifiOffloadHidlEnvironment::Instance() 98 ->getServiceName<IOffload>()); 99 ASSERT_NE(wifi_offload_, nullptr); 100 101 wifi_offload_cb_ = new OffloadCallback(); 102 ASSERT_NE(wifi_offload_cb_, nullptr); 103 } 104 105 virtual void TearDown() override {} 106 107 /* Callback class for Offload HAL. */ 108 class OffloadCallback 109 : public ::testing::VtsHalHidlTargetCallbackBase<OffloadCallbackArgs>, 110 public IOffloadCallback { 111 public: 112 OffloadCallback(){}; 113 114 virtual ~OffloadCallback() = default; 115 116 Return<void> onScanResult( 117 const hidl_vec<ScanResult>& scan_result) override { 118 OffloadCallbackArgs args; 119 args.scan_results_ = scan_result; 120 NotifyFromCallback(kOffloadCallbackSendScanResult, args); 121 return Void(); 122 }; 123 124 Return<void> onError(const OffloadStatus& status) override { 125 OffloadCallbackArgs args; 126 args.error_code_ = status; 127 NotifyFromCallback(kOffloadCallbackSendError, args); 128 return Void(); 129 } 130 }; 131 132 sp<IOffload> wifi_offload_; 133 sp<OffloadCallback> wifi_offload_cb_; 134 }; 135 136 /* 137 * Verify that setEventCallback method returns without errors 138 */ 139 TEST_F(WifiOffloadHidlTest, setEventCallback) { 140 auto returnObject = wifi_offload_->setEventCallback(wifi_offload_cb_); 141 ASSERT_EQ(true, returnObject.isOk()); 142 } 143 144 /* 145 * Verify that subscribeScanResults method returns without errors 146 */ 147 TEST_F(WifiOffloadHidlTest, subscribeScanResults) { 148 const auto& result = HIDL_INVOKE(wifi_offload_, subscribeScanResults, 0); 149 ASSERT_EQ(OffloadStatusCode::OK, result.code); 150 } 151 152 /* 153 * Verify that unsubscribeScanResults method returns without errors 154 */ 155 TEST_F(WifiOffloadHidlTest, unsubscribeScanResults) { 156 auto returnObject = wifi_offload_->unsubscribeScanResults(); 157 ASSERT_EQ(true, returnObject.isOk()); 158 } 159 160 /* 161 * Verify that configureScans method returns without errors 162 */ 163 TEST_F(WifiOffloadHidlTest, configureScans) { 164 ScanParam* pScanParam = new ScanParam(); 165 std::vector<uint32_t> frequencyList = {kFrequency1, kFrequency2}; 166 pScanParam->disconnectedModeScanIntervalMs = 167 kDisconnectedModeScanIntervalMs; 168 pScanParam->frequencyList = frequencyList; 169 std::vector<Ssid> ssidList; 170 std::vector<std::vector<uint8_t>> ssids{kSsid1, kSsid2}; 171 for (const auto& ssid : ssids) { 172 Ssid tmp = ssid; 173 ssidList.push_back(tmp); 174 } 175 pScanParam->ssidList = ssidList; 176 ScanFilter* pScanFilter = new ScanFilter(); 177 pScanFilter->rssiThreshold = kRssiThreshold; 178 std::vector<std::vector<uint8_t>> match_ssids{kSsid1, kSsid2}; 179 std::vector<uint8_t> security_flags{kNetworkFlags, kNetworkFlags}; 180 std::vector<NetworkInfo> preferredNetworksList; 181 for (size_t i = 0; i < security_flags.size(); i++) { 182 NetworkInfo nwInfo; 183 nwInfo.ssid = match_ssids[i]; 184 nwInfo.flags = security_flags[i]; 185 preferredNetworksList.push_back(nwInfo); 186 } 187 const auto& result = 188 HIDL_INVOKE(wifi_offload_, configureScans, *pScanParam, *pScanFilter); 189 ASSERT_EQ(OffloadStatusCode::OK, result.code); 190 } 191 192 /* 193 * Verify that getScanStats returns without any errors 194 */ 195 TEST_F(WifiOffloadHidlTest, getScanStats) { 196 const auto& result = HIDL_INVOKE(wifi_offload_, getScanStats); 197 OffloadStatus status = result.first; 198 ASSERT_EQ(OffloadStatusCode::OK, status.code); 199 } 200 201 /* 202 * Verify that onScanResult callback is invoked 203 */ 204 TEST_F(WifiOffloadHidlTest, getScanResults) { 205 wifi_offload_->setEventCallback(wifi_offload_cb_); 206 std::vector<ScanResult> scan_results; 207 std::vector<uint8_t> ssid(kSsid1, kSsid1 + sizeof(kSsid1)); 208 ScanResult scan_result; 209 scan_result.tsf = kTsf; 210 scan_result.rssi = kRssi; 211 scan_result.frequency = kFrequency; 212 scan_result.capability = kCapability; 213 memcpy(&scan_result.bssid[0], &kBssid[0], kBssidSize); 214 scan_result.networkInfo.ssid = ssid; 215 scan_result.networkInfo.flags = kNetworkFlags; 216 scan_results.push_back(scan_result); 217 wifi_offload_cb_->onScanResult(scan_results); 218 auto res = 219 wifi_offload_cb_->WaitForCallback(kOffloadCallbackSendScanResult); 220 ASSERT_EQ(true, res.no_timeout); 221 } 222 223 /* 224 * Verify that onError callback is invoked 225 */ 226 TEST_F(WifiOffloadHidlTest, getError) { 227 wifi_offload_->setEventCallback(wifi_offload_cb_); 228 OffloadStatus status = {OffloadStatusCode::ERROR, ""}; 229 wifi_offload_cb_->onError(status); 230 auto res = wifi_offload_cb_->WaitForCallback(kOffloadCallbackSendError); 231 ASSERT_EQ(true, res.no_timeout); 232 } 233 234 int main(int argc, char** argv) { 235 ::testing::AddGlobalTestEnvironment(WifiOffloadHidlEnvironment::Instance()); 236 ::testing::InitGoogleTest(&argc, argv); 237 WifiOffloadHidlEnvironment::Instance()->init(&argc, argv); 238 int status = RUN_ALL_TESTS(); 239 LOG(INFO) << "Test result = " << status; 240 241 return status; 242 } 243
