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
Instance()77 static WifiOffloadHidlEnvironment* Instance() {
78 static WifiOffloadHidlEnvironment* instance =
79 new WifiOffloadHidlEnvironment;
80 return instance;
81 }
82
registerTestServices()83 virtual void registerTestServices() override {
84 registerTestService<IOffload>();
85 }
86
87 private:
WifiOffloadHidlEnvironment()88 WifiOffloadHidlEnvironment() {}
89 };
90
91 // The main test class for WifiOffload HIDL HAL.
92 class WifiOffloadHidlTest : public ::testing::VtsHalHidlTargetTestBase {
93 public:
SetUp()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
TearDown()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:
OffloadCallback()112 OffloadCallback(){};
113
114 virtual ~OffloadCallback() = default;
115
onScanResult(const hidl_vec<ScanResult> & scan_result)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
onError(const OffloadStatus & status)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 */
TEST_F(WifiOffloadHidlTest,setEventCallback)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 */
TEST_F(WifiOffloadHidlTest,subscribeScanResults)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 */
TEST_F(WifiOffloadHidlTest,unsubscribeScanResults)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 */
TEST_F(WifiOffloadHidlTest,configureScans)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 */
TEST_F(WifiOffloadHidlTest,getScanStats)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 */
TEST_F(WifiOffloadHidlTest,getScanResults)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 */
TEST_F(WifiOffloadHidlTest,getError)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
main(int argc,char ** argv)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