1/*
2 * Copyright (c) 2021-2022 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 <osal_mem.h>
18#include "wifi_driver_client.h"
19
20using namespace testing::ext;
21
22namespace ClientTest {
23const uint32_t DEFAULT_COMBO_SIZE = 10;
24const char *WLAN_IFNAME = "wlan0";
25const uint32_t RESET_TIME = 20;
26class WifiClientTest : public testing::Test {
27public:
28    static void SetUpTestCase();
29    static void TearDownTestCase();
30    void SetUp();
31    void TearDown();
32};
33
34void WifiClientTest::SetUpTestCase()
35{
36}
37
38void WifiClientTest::TearDownTestCase()
39{
40}
41
42void WifiClientTest::SetUp()
43{
44    WifiDriverClientInit();
45}
46
47void WifiClientTest::TearDown()
48{
49    WifiDriverClientDeinit();
50}
51
52/**
53 * @tc.name: WifiClientSetCountryCode001
54 * @tc.desc: Wifi client set country code function test
55 * @tc.type: FUNC
56 */
57HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_SetCountryCode_0001, Function | MediumTest | Level1)
58{
59    int32_t ret;
60    const char *code = "CN";
61    const char *codeDigital = "99";
62    uint32_t len = 2;
63
64    ret = WifiSetCountryCode(WLAN_IFNAME, code, len);
65    EXPECT_EQ(RET_CODE_SUCCESS, ret);
66    ret = WifiSetCountryCode(WLAN_IFNAME, codeDigital, len);
67    bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
68    ASSERT_TRUE(flag);
69}
70
71/**
72 * @tc.name: WifiClientGetUsableNetworkInfo001
73 * @tc.desc: Wifi client get usable networkInfo function test
74 * @tc.type: FUNC
75 */
76HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_GetUsableNetworkInfo_0001, Function | MediumTest | Level1)
77{
78    int32_t ret;
79    struct NetworkInfoResult networkInfo;
80
81    ret = GetUsableNetworkInfo(&networkInfo);
82    EXPECT_EQ(RET_CODE_SUCCESS, ret);
83}
84
85/**
86 * @tc.name: WifiClientIsSupportCombo001
87 * @tc.desc: Wifi client is support combo function test
88 * @tc.type: FUNC
89 */
90HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_IsSupportCombo_0001, Function | MediumTest | Level1)
91{
92    int32_t ret;
93    uint8_t isSupportCombo;
94
95    ret = IsSupportCombo(&isSupportCombo);
96    EXPECT_EQ(RET_CODE_SUCCESS, ret);
97}
98
99/**
100 * @tc.name: WifiClientGetComboInfo001
101 * @tc.desc: Wifi client get combo info function test
102 * @tc.type: FUNC
103 */
104HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_GetComboInfo_0001, Function | MediumTest | Level1)
105{
106    int32_t ret;
107    uint64_t comboInfo[DEFAULT_COMBO_SIZE] = {};
108
109    ret = GetComboInfo(comboInfo, DEFAULT_COMBO_SIZE);
110    bool flag = (ret == RET_CODE_SUCCESS || ret == RET_CODE_NOT_SUPPORT);
111    ASSERT_TRUE(flag);
112}
113
114/**
115 * @tc.name: WifiClientSetMacAddr001
116 * @tc.desc: Wifi client set mac addr function test
117 * @tc.type: FUNC
118 */
119HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_SetMacAddr_0001, Function | MediumTest | Level1)
120{
121    int32_t ret;
122    unsigned char mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
123    unsigned char errorMac[ETH_ADDR_LEN] = {0x11, 0x34, 0x56, 0x78, 0xab, 0xcd};
124
125    ret = SetMacAddr(WLAN_IFNAME, mac, ETH_ADDR_LEN);
126    bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_DEVICE_BUSY);
127    ASSERT_TRUE(flag);
128    ret = SetMacAddr(WLAN_IFNAME, errorMac, ETH_ADDR_LEN);
129    EXPECT_NE(RET_CODE_SUCCESS, ret);
130}
131
132/**
133 * @tc.name: WifiClientGetDevMacAddr001
134 * @tc.desc: Wifi client get mac addr function test
135 * @tc.type: FUNC
136 */
137HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_GetDevMacAddr_0001, Function | MediumTest | Level1)
138{
139    int32_t ret;
140    unsigned char mac[ETH_ADDR_LEN] = {};
141    int32_t type = WIFI_IFTYPE_STATION;
142
143    ret = GetDevMacAddr(WLAN_IFNAME, type, mac, ETH_ADDR_LEN);
144    EXPECT_NE(RET_CODE_FAILURE, ret);
145}
146
147/**
148 * @tc.name: WifiClientGetDevMacAddr002
149 * @tc.desc: Wifi client get mac addr function test
150 * @tc.type: FUNC
151 */
152HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_GetDevMacAddr_0002, Function | MediumTest | Level1)
153{
154    int32_t ret;
155    unsigned char mac[ETH_ADDR_LEN] = {};
156    int32_t type = WIFI_IFTYPE_AP;
157
158    ret = GetDevMacAddr(WLAN_IFNAME, type, mac, ETH_ADDR_LEN);
159    EXPECT_NE(RET_CODE_FAILURE, ret);
160}
161
162/**
163 * @tc.name: WifiClientGetValidFreqByBand001
164 * @tc.desc: Wifi client get valid freq function test
165 * @tc.type: FUNC
166 */
167HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_GetValidFreqByBand_0001, Function | MediumTest | Level1)
168{
169    int32_t ret;
170    int32_t band = IEEE80211_BAND_2GHZ;
171    int32_t bandNotSupport = IEEE80211_NUM_BANDS;
172    struct FreqInfoResult result;
173    uint32_t size = 14;
174    uint32_t i;
175
176    result.freqs = (uint32_t *)OsalMemCalloc(35 * sizeof(uint32_t));
177    if (result.freqs == NULL) {
178        printf("%s: OsalMemCalloc failed", __FUNCTION__);
179        return;
180    }
181
182    result.txPower = (uint32_t *)OsalMemCalloc(35 * sizeof(uint32_t));
183    if (result.txPower == NULL) {
184        printf("%s: OsalMemCalloc failed", __FUNCTION__);
185        OsalMemFree(result.freqs);
186        return;
187    }
188
189    ret = GetValidFreqByBand(WLAN_IFNAME, bandNotSupport, &result, size);
190    EXPECT_NE(RET_CODE_SUCCESS, ret);
191    ret = GetValidFreqByBand(WLAN_IFNAME, band, &result, size);
192    EXPECT_EQ(RET_CODE_SUCCESS, ret);
193    if (ret == RET_CODE_SUCCESS) {
194        printf("%s: num = %u\n", __func__, result.nums);
195        for (i = 0; i < result.nums; i++) {
196            printf("%s: freq[%d] = %d\n", __func__, i, result.freqs[i]);
197        }
198    }
199
200    OsalMemFree(result.txPower);
201    OsalMemFree(result.freqs);
202}
203
204/**
205 * @tc.name: WifiClientSetTxPower001
206 * @tc.desc: Wifi client set tx power function test
207 * @tc.type: FUNC
208 */
209HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_SetTxPower_0001, Function | MediumTest | Level1)
210{
211    int32_t ret;
212    int32_t power = 10;
213
214    ret = SetTxPower(WLAN_IFNAME, power);
215    EXPECT_EQ(RET_CODE_SUCCESS, ret);
216}
217
218/**
219 * @tc.name: WifiClientGetAssociatedStas001
220 * @tc.desc: Wifi client get associated status function test
221 * @tc.type: FUNC
222 */
223HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_GetAssociatedStas_0001, Function | MediumTest | Level1)
224{
225    int32_t ret;
226    struct AssocStaInfoResult result;
227
228    ret = GetAssociatedStas(WLAN_IFNAME, &result);
229    EXPECT_EQ(RET_CODE_SUCCESS, ret);
230}
231
232/**
233 * @tc.name: WifiClientSetScanMacAddr001
234 * @tc.desc: Wifi client set scan MAC address function test
235 * @tc.type: FUNC
236 */
237HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_SetScanMacAddr_0001, Function | MediumTest | Level1)
238{
239    int32_t ret;
240    unsigned char scanMac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
241
242    ret = SetScanMacAddr(WLAN_IFNAME, scanMac, ETH_ADDR_LEN);
243    bool flag = (ret == RET_CODE_SUCCESS || ret == RET_CODE_NOT_SUPPORT);
244    ASSERT_TRUE(flag);
245}
246
247/**
248 * @tc.name: WifiClientAcquireChipId001
249 * @tc.desc: Wifi client get chipId function test
250 * @tc.type: FUNC
251 */
252HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_AcquireChipId_0001, Function | MediumTest | Level1)
253{
254    int32_t ret;
255    const char *ifNameInvalid = "wlanTest";
256    uint8_t chipId = 0;
257
258    ret = AcquireChipId(ifNameInvalid, &chipId);
259    EXPECT_NE(RET_CODE_SUCCESS, ret);
260    ret = AcquireChipId(WLAN_IFNAME, &chipId);
261    ASSERT_TRUE(chipId < MAX_WLAN_DEVICE);
262    EXPECT_EQ(RET_CODE_SUCCESS, ret);
263}
264
265/**
266 * @tc.name: WifiClientGetIfNamesByChipId001
267 * @tc.desc: Wifi client get ifName by chipId function test
268 * @tc.type: FUNC
269 */
270HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_GetIfNamesByChipId_0001, Function | MediumTest | Level1)
271{
272    int32_t ret;
273    uint8_t chipId = 0;
274    uint8_t chipIdInvalid = 100;
275    char *ifNames = nullptr;
276    uint32_t num = 0;
277
278    ret = AcquireChipId(WLAN_IFNAME, &chipId);
279    ASSERT_TRUE(chipId < MAX_WLAN_DEVICE);
280    EXPECT_EQ(RET_CODE_SUCCESS, ret);
281    ret = GetIfNamesByChipId(chipIdInvalid, &ifNames, &num);
282    EXPECT_NE(RET_CODE_SUCCESS, ret);
283    ret = GetIfNamesByChipId(chipId, &ifNames, &num);
284    EXPECT_NE(ifNames, nullptr);
285    EXPECT_EQ(RET_CODE_SUCCESS, ret);
286    free(ifNames);
287}
288
289/**
290 * @tc.name: WifiClientGetNetDeviceInfo001
291 * @tc.desc: Wifi client get netDevice information function test
292 * @tc.type: FUNC
293 */
294HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_GetNetDeviceInfo_0001, Function | MediumTest | Level1)
295{
296    int32_t ret;
297    struct NetDeviceInfoResult netDeviceInfoResult;
298
299    ret = GetNetDeviceInfo(&netDeviceInfoResult);
300    EXPECT_EQ(RET_CODE_SUCCESS, ret);
301}
302
303/**
304 * @tc.name: WifiClientGetCurrentPowerMode001
305 * @tc.desc: Wifi client get current power mode function test
306 * @tc.type: FUNC
307 */
308HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_GetCurrentPowerMode_0001, Function | MediumTest | Level1)
309{
310    int32_t ret;
311    uint8_t mode = 0;
312    const char *ifNameInvalid = "wlanTest";
313
314    ret = GetCurrentPowerMode(ifNameInvalid, &mode);
315    EXPECT_NE(RET_CODE_SUCCESS, ret);
316    ret = GetCurrentPowerMode(WLAN_IFNAME, &mode);
317    bool flag = (ret == RET_CODE_SUCCESS || ret == RET_CODE_NOT_SUPPORT);
318    ASSERT_TRUE(flag);
319}
320
321/**
322 * @tc.name: WifiClientSetPowerMode001
323 * @tc.desc: Wifi client set power mode function test
324 * @tc.type: FUNC
325 */
326HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_SetPowerMode_0001, Function | MediumTest | Level1)
327{
328    int32_t ret;
329    const char *ifNameInvalid = "wlanTest";
330
331    ret = SetPowerMode(ifNameInvalid, WIFI_POWER_MODE_SLEEPING);
332    EXPECT_NE(RET_CODE_SUCCESS, ret);
333    ret = SetPowerMode(WLAN_IFNAME, WIFI_POWER_MODE_SLEEPING);
334    bool flag = (ret == RET_CODE_SUCCESS || ret == RET_CODE_NOT_SUPPORT);
335    ASSERT_TRUE(flag);
336}
337
338/**
339 * @tc.name: WifiClientSetPowerMode002
340 * @tc.desc: Wifi client set power mode function test
341 * @tc.type: FUNC
342 */
343HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_SetPowerMode_0002, Function | MediumTest | Level1)
344{
345    int32_t ret;
346
347    ret = SetPowerMode(WLAN_IFNAME, WIFI_POWER_MODE_GENERAL);
348    bool flag = (ret == RET_CODE_SUCCESS || ret == RET_CODE_NOT_SUPPORT);
349    ASSERT_TRUE(flag);
350}
351
352/**
353 * @tc.name: WifiClientSetPowerMode003
354 * @tc.desc: Wifi client set power mode function test
355 * @tc.type: FUNC
356 */
357HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_SetPowerMode_0003, Function | MediumTest | Level1)
358{
359    int32_t ret;
360
361    ret = SetPowerMode(WLAN_IFNAME, WIFI_POWER_MODE_THROUGH_WALL);
362    bool flag = (ret == RET_CODE_SUCCESS || ret == RET_CODE_NOT_SUPPORT);
363    ASSERT_TRUE(flag);
364}
365
366/**
367 * @tc.name: WifiClientSetPowerMode004
368 * @tc.desc: Wifi client set power mode function test
369 * @tc.type: FUNC
370 */
371HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_SetPowerMode_0004, Function | MediumTest | Level1)
372{
373    int32_t ret;
374
375    ret = SetPowerMode(WLAN_IFNAME, WIFI_POWER_MODE_NUM);
376    EXPECT_NE(RET_CODE_SUCCESS, ret);
377}
378
379/**
380 * @tc.name: WifiClientSetResetDriver001
381 * @tc.desc: Wifi client reset driver function test
382 * @tc.type: FUNC
383 */
384HWTEST_F(WifiClientTest, SUB_WLAN_CLIENT_SetResetDriver_0001, Function | MediumTest | Level1)
385{
386    int32_t ret;
387    uint8_t chipId = 0;
388
389    ret = AcquireChipId(WLAN_IFNAME, &chipId);
390    ASSERT_TRUE(chipId < MAX_WLAN_DEVICE);
391    EXPECT_EQ(RET_CODE_SUCCESS, ret);
392
393    ret = SetResetDriver(chipId, WLAN_IFNAME);
394    EXPECT_EQ(RET_CODE_SUCCESS, ret);
395    sleep(RESET_TIME);
396}
397};
398