1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "hdf_base.h"
18 #include "hdf_sbuf.h"
19 #include "wifi_hal.h"
20 #include "wifi_hal_ap_feature.h"
21 #include "wifi_hal_base_feature.h"
22 #include "wifi_hal_sta_feature.h"
23
24 using namespace testing::ext;
25
26 namespace HalTest {
27 struct IWiFi *g_wifi = nullptr;
28 const int32_t USEC_TIME = 1000000;
29 const int32_t MSEC_TIME = 1000;
30 const int32_t COMMON_TIME = 18000;
31 const int32_t MEDIUM_TIME = 20000;
32 const int32_t LONG_TIME = 200000;
33 const int32_t WLAN_BAND_2G = 0;
34 const int32_t WLAN_FREQ_MAX_NUM = 14;
35 const int32_t WLAN_MAX_NUM_STA_WITH_AP = 4;
36 const uint32_t DEFAULT_COMBO_SIZE = 10;
37 const uint32_t RESET_TIME = 20;
38 const uint32_t WLAN_MIN_CHIPID = 0;
39 const uint32_t WLAN_MAX_CHIPID = 2;
40
41 static int32_t g_resetStatus = -1;
42
43 class HdfWlanPerformanceTest : public testing::Test {
44 public:
45 static void SetUpTestCase();
46 static void TearDownTestCase();
47 void SetUp();
48 void TearDown();
49 };
50
SetUpTestCase()51 void HdfWlanPerformanceTest::SetUpTestCase()
52 {
53 int ret;
54
55 ret = WifiConstruct(&g_wifi);
56 ASSERT_EQ(HDF_SUCCESS, ret);
57 }
58
TearDownTestCase()59 void HdfWlanPerformanceTest::TearDownTestCase()
60 {
61 int ret;
62
63 ret = WifiDestruct(&g_wifi);
64 ASSERT_EQ(HDF_SUCCESS, ret);
65 }
66
SetUp()67 void HdfWlanPerformanceTest::SetUp()
68 {
69 int ret;
70
71 ret = g_wifi->start(nullptr);
72 ASSERT_EQ(HDF_ERR_INVALID_PARAM, ret);
73 ret = g_wifi->start(g_wifi);
74 ASSERT_EQ(HDF_SUCCESS, ret);
75 }
76
TearDown()77 void HdfWlanPerformanceTest::TearDown()
78 {
79 int ret;
80
81 ret = g_wifi->stop(nullptr);
82 ASSERT_EQ(HDF_ERR_INVALID_PARAM, ret);
83 ret = g_wifi->stop(g_wifi);
84 ASSERT_EQ(HDF_SUCCESS, ret);
85 }
86
HalResetCallbackEvent(uint32_t event,void * data,const char * ifName)87 static int32_t HalResetCallbackEvent(uint32_t event, void *data, const char *ifName)
88 {
89 (void)event;
90 (void)ifName;
91 int *resetStatus = nullptr;
92 resetStatus = (int *)data;
93 printf("HalResetCallbackEvent: receive resetStatus=%d \n", *resetStatus);
94 g_resetStatus = *resetStatus;
95 return HDF_SUCCESS;
96 }
97
98 /**
99 * @tc.name: WifiHalGetSupportFeature001
100 * @tc.desc: Get supported features
101 * @tc.type: FUNC
102 * @tc.require: AR000F869J
103 */
104 HWTEST_F(HdfWlanPerformanceTest, WifiHalGetSupportFeature001, TestSize.Level1)
105 {
106 int ret;
107 uint8_t supportTest[PROTOCOL_80211_IFTYPE_NUM] = {0};
108 uint8_t support[PROTOCOL_80211_IFTYPE_NUM + 1] = {0};
109 struct timespec tv1 = (struct timespec){0};
110 struct timespec tv2 = (struct timespec){0};
111 int timeUsed = 0;
112
113 ret = g_wifi->getSupportFeature(nullptr, 0);
114 EXPECT_NE(HDF_SUCCESS, ret);
115 ret = g_wifi->getSupportFeature(supportTest, PROTOCOL_80211_IFTYPE_NUM);
116 EXPECT_NE(HDF_SUCCESS, ret);
117 clock_gettime(CLOCK_REALTIME, &tv1);
118 ret = g_wifi->getSupportFeature(support, PROTOCOL_80211_IFTYPE_NUM + 1);
119 clock_gettime(CLOCK_REALTIME, &tv2);
120 timeUsed = ((tv2.tv_sec * USEC_TIME + tv2.tv_nsec / MSEC_TIME) -
121 (tv1.tv_sec * USEC_TIME + tv1.tv_nsec / MSEC_TIME));
122 EXPECT_GE(COMMON_TIME, timeUsed);
123 EXPECT_EQ(HDF_SUCCESS, ret);
124 }
125
126 /**
127 * @tc.name: WifiHalGetSupportCombo001
128 * @tc.desc: Get supported combo
129 * @tc.type: FUNC
130 * @tc.require: AR000F869J
131 */
132 HWTEST_F(HdfWlanPerformanceTest, WifiHalGetSupportCombo001, TestSize.Level1)
133 {
134 int ret;
135 uint8_t support[PROTOCOL_80211_IFTYPE_NUM + 1] = {0};
136 uint64_t combo[DEFAULT_COMBO_SIZE] = {0};
137 struct timespec tv1 = (struct timespec){0};
138 struct timespec tv2 = (struct timespec){0};
139 int timeUsed = 0;
140
141 ret = g_wifi->getSupportFeature(support, PROTOCOL_80211_IFTYPE_NUM + 1);
142 EXPECT_EQ(HDF_SUCCESS, ret);
143 ret = g_wifi->getSupportCombo(nullptr, 0);
144 EXPECT_NE(HDF_SUCCESS, ret);
145 clock_gettime(CLOCK_REALTIME, &tv1);
146 ret = g_wifi->getSupportCombo(combo, DEFAULT_COMBO_SIZE);
147 clock_gettime(CLOCK_REALTIME, &tv2);
148 timeUsed = ((tv2.tv_sec * USEC_TIME + tv2.tv_nsec / MSEC_TIME) -
149 (tv1.tv_sec * USEC_TIME + tv1.tv_nsec / MSEC_TIME));
150 EXPECT_GE(COMMON_TIME, timeUsed);
151 if (support[PROTOCOL_80211_IFTYPE_NUM] == 0) {
152 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
153 } else {
154 EXPECT_EQ(HDF_SUCCESS, ret);
155 }
156 }
157
158 /**
159 * @tc.name: WifiHalGetDeviceMacAddress001
160 * @tc.desc: Get device Mac address for ap mode
161 * @tc.type: FUNC
162 * @tc.require: AR000F869G
163 */
164 HWTEST_F(HdfWlanPerformanceTest, WifiHalGetDeviceMacAddress001, TestSize.Level1)
165 {
166 int ret;
167 struct IWiFiAp *apFeature = nullptr;
168 unsigned char mac[ETH_ADDR_LEN] = {0};
169 struct timespec tv1 = (struct timespec){0};
170 struct timespec tv2 = (struct timespec){0};
171 int timeUsed = 0;
172
173 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
174 EXPECT_EQ(HDF_SUCCESS, ret);
175 EXPECT_NE(nullptr, apFeature);
176 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, nullptr, 0);
177 EXPECT_NE(HDF_SUCCESS, ret);
178 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, mac, ETH_ADDR_LEN - 1);
179 EXPECT_NE(HDF_SUCCESS, ret);
180 clock_gettime(CLOCK_REALTIME, &tv1);
181 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, mac, ETH_ADDR_LEN);
182 clock_gettime(CLOCK_REALTIME, &tv2);
183 timeUsed = ((tv2.tv_sec * USEC_TIME + tv2.tv_nsec / MSEC_TIME) -
184 (tv1.tv_sec * USEC_TIME + tv1.tv_nsec / MSEC_TIME));
185 EXPECT_GE(LONG_TIME, timeUsed);
186 EXPECT_NE(HDF_FAILURE, ret);
187
188 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
189 EXPECT_EQ(HDF_SUCCESS, ret);
190 }
191
192 /**
193 * @tc.name: WifiHalGetDeviceMacAddress002
194 * @tc.desc: Get device Mac address for sta mode
195 * @tc.type: FUNC
196 * @tc.require: AR000F869E
197 */
198 HWTEST_F(HdfWlanPerformanceTest, WifiHalGetDeviceMacAddress002, TestSize.Level1)
199 {
200 int ret;
201 struct IWiFiSta *staFeature = nullptr;
202 unsigned char mac[ETH_ADDR_LEN] = {0};
203 struct timespec tv1 = (struct timespec){0};
204 struct timespec tv2 = (struct timespec){0};
205 int timeUsed = 0;
206
207 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
208 EXPECT_EQ(HDF_SUCCESS, ret);
209 EXPECT_NE(nullptr, staFeature);
210 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, nullptr, 0);
211 EXPECT_NE(HDF_SUCCESS, ret);
212 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, mac, ETH_ADDR_LEN - 1);
213 EXPECT_NE(HDF_SUCCESS, ret);
214 clock_gettime(CLOCK_REALTIME, &tv1);
215 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, mac, ETH_ADDR_LEN);
216 clock_gettime(CLOCK_REALTIME, &tv2);
217 timeUsed = ((tv2.tv_sec * USEC_TIME + tv2.tv_nsec / MSEC_TIME) -
218 (tv1.tv_sec * USEC_TIME + tv1.tv_nsec / MSEC_TIME));
219 EXPECT_GE(LONG_TIME, timeUsed);
220 EXPECT_NE(HDF_FAILURE, ret);
221
222 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
223 EXPECT_EQ(HDF_SUCCESS, ret);
224 }
225
226 /**
227 * @tc.name: WifiHaGetValidFreqsWithBand001
228 * @tc.desc: Get available frequencies
229 * @tc.type: FUNC
230 * @tc.require: AR000F869G
231 */
232 HWTEST_F(HdfWlanPerformanceTest, WifiHaGetValidFreqsWithBand001, TestSize.Level1)
233 {
234 int ret;
235 struct IWiFiAp *apFeature = nullptr;
236 int32_t freq[WLAN_FREQ_MAX_NUM] = {0};
237 uint32_t num = 0;
238 struct timespec tv1 = (struct timespec){0};
239 struct timespec tv2 = (struct timespec){0};
240 int timeUsed = 0;
241
242 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
243 EXPECT_EQ(HDF_SUCCESS, ret);
244 EXPECT_NE(nullptr, apFeature);
245 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature,
246 WLAN_BAND_2G, nullptr, 0, nullptr);
247 EXPECT_NE(HDF_SUCCESS, ret);
248 clock_gettime(CLOCK_REALTIME, &tv1);
249 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature,
250 WLAN_BAND_2G, freq, WLAN_FREQ_MAX_NUM, &num);
251 clock_gettime(CLOCK_REALTIME, &tv2);
252 timeUsed = ((tv2.tv_sec * USEC_TIME + tv2.tv_nsec / MSEC_TIME) -
253 (tv1.tv_sec * USEC_TIME + tv1.tv_nsec / MSEC_TIME));
254 EXPECT_GE(COMMON_TIME, timeUsed);
255 EXPECT_EQ(HDF_SUCCESS, ret);
256
257 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
258 EXPECT_EQ(HDF_SUCCESS, ret);
259 }
260
261 /**
262 * @tc.name: WifiHalGetAssociatedStas001
263 * @tc.desc: Get associated STA info
264 * @tc.type: FUNC
265 * @tc.require: AR000F869K
266 */
267 HWTEST_F(HdfWlanPerformanceTest, WifiHalGetAssociatedStas001, TestSize.Level1)
268 {
269 int ret;
270 struct IWiFiAp *apFeature = nullptr;
271 struct StaInfo staInfo[WLAN_MAX_NUM_STA_WITH_AP] = {{0}};
272 uint32_t num = 0;
273 struct timespec tv1 = (struct timespec){0};
274 struct timespec tv2 = (struct timespec){0};
275 int timeUsed = 0;
276
277 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
278 EXPECT_EQ(HDF_SUCCESS, ret);
279 EXPECT_NE(nullptr, apFeature);
280 ret = apFeature->getAssociatedStas(apFeature, nullptr, 0, nullptr);
281 EXPECT_NE(HDF_SUCCESS, ret);
282 clock_gettime(CLOCK_REALTIME, &tv1);
283 ret = apFeature->getAssociatedStas(apFeature, staInfo, WLAN_MAX_NUM_STA_WITH_AP, &num);
284 clock_gettime(CLOCK_REALTIME, &tv2);
285 timeUsed = ((tv2.tv_sec * USEC_TIME + tv2.tv_nsec / MSEC_TIME) -
286 (tv1.tv_sec * USEC_TIME + tv1.tv_nsec / MSEC_TIME));
287 EXPECT_GE(COMMON_TIME, timeUsed);
288 EXPECT_EQ(HDF_SUCCESS, ret);
289
290 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
291 EXPECT_EQ(HDF_SUCCESS, ret);
292 }
293
294 /**
295 * @tc.name: WifiHalSetScanningMacAddress001
296 * @tc.desc: Set Mac address scanning
297 * @tc.type: FUNC
298 * @tc.require: AR000F869K
299 */
300 HWTEST_F(HdfWlanPerformanceTest, WifiHalSetScanningMacAddress001, TestSize.Level1)
301 {
302 int ret;
303 struct IWiFiSta *staFeature = nullptr;
304 unsigned char scanMac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
305 struct timespec tv1 = (struct timespec){0};
306 struct timespec tv2 = (struct timespec){0};
307 int timeUsed = 0;
308
309 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
310 EXPECT_EQ(HDF_SUCCESS, ret);
311 EXPECT_NE(nullptr, staFeature);
312 ret = staFeature->setScanningMacAddress(staFeature, nullptr, 0);
313 EXPECT_NE(HDF_SUCCESS, ret);
314 clock_gettime(CLOCK_REALTIME, &tv1);
315 ret = staFeature->setScanningMacAddress(staFeature, scanMac, ETH_ADDR_LEN);
316 clock_gettime(CLOCK_REALTIME, &tv2);
317 timeUsed = ((tv2.tv_sec * USEC_TIME + tv2.tv_nsec / MSEC_TIME) -
318 (tv1.tv_sec * USEC_TIME + tv1.tv_nsec / MSEC_TIME));
319 EXPECT_GE(LONG_TIME, timeUsed);
320 EXPECT_NE(HDF_FAILURE, ret);
321
322 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
323 EXPECT_EQ(HDF_SUCCESS, ret);
324 }
325
326 /**
327 * @tc.name: WifiHalGetChipId001
328 * @tc.desc: Obtain the chip ID
329 * @tc.type: FUNC
330 * @tc.require: AR000F869G
331 */
332 HWTEST_F(HdfWlanPerformanceTest, WifiHalGetChipId001, TestSize.Level1)
333 {
334 int ret;
335 struct IWiFiSta *staFeature = nullptr;
336 unsigned char chipId = 0;
337 struct timespec tv1 = (struct timespec){0};
338 struct timespec tv2 = (struct timespec){0};
339 int timeUsed = 0;
340
341 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
342 EXPECT_EQ(HDF_SUCCESS, ret);
343 EXPECT_NE(nullptr, staFeature);
344 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, nullptr);
345 EXPECT_NE(HDF_SUCCESS, ret);
346 clock_gettime(CLOCK_REALTIME, &tv1);
347 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId);
348 clock_gettime(CLOCK_REALTIME, &tv2);
349 timeUsed = ((tv2.tv_sec * USEC_TIME + tv2.tv_nsec / MSEC_TIME) -
350 (tv1.tv_sec * USEC_TIME + tv1.tv_nsec / MSEC_TIME));
351 EXPECT_GE(MEDIUM_TIME, timeUsed);
352 ASSERT_TRUE(chipId <= WLAN_MAX_CHIPID && chipId >= WLAN_MIN_CHIPID);
353 EXPECT_EQ(HDF_SUCCESS, ret);
354
355 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
356 EXPECT_EQ(HDF_SUCCESS, ret);
357 }
358
359 /**
360 * @tc.name: WifiHalRegisterEventCallback001
361 * @tc.desc: Wifi hal register callback function test
362 * @tc.type: FUNC
363 * @tc.require: AR000F869G
364 */
365 HWTEST_F(HdfWlanPerformanceTest, WifiHalRegisterEventCallback001, TestSize.Level1)
366 {
367 int ret;
368
369 ret = g_wifi->registerEventCallback(HalResetCallbackEvent, "wlan0");
370 sleep(RESET_TIME);
371 EXPECT_EQ(HDF_SUCCESS, ret);
372 }
373 };
374