1/*
2 * Copyright (c) 2023 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#include <gtest/gtest.h>
16#include <servmgr_hdi.h>
17#include "v1_3/iwlan_interface.h"
18#include "wlan_callback_impl.h"
19#include "securec.h"
20#include "wlan_hdi_types.h"
21
22#define HDF_LOG_TAG service_manager_test
23using namespace testing::ext;
24
25namespace HdiDirectTest {
26const int32_t DEFAULT_COMBO_SIZE = 6;
27const int32_t WLAN_MAX_NUM_STA_WITH_AP = 4;
28const int32_t WLAN_FREQ_MAX_NUM = 35;
29const int32_t WLAN_TX_POWER = 160;
30const char *WLAN_SERVICE_NAME = "wlan_interface_service";
31
32class HdfWifiDirectTest : public testing::Test {
33public:
34    static void SetUpTestCase();
35    static void TearDownTestCase();
36    void SetUp();
37    void TearDown();
38};
39
40static struct IWlanInterface *g_wlanObj = nullptr;
41struct IWlanCallback *g_wlanCallbackObj = nullptr;
42void HdfWifiDirectTest::SetUpTestCase()
43{
44    g_wlanObj = IWlanInterfaceGetInstance(WLAN_SERVICE_NAME, true);
45    g_wlanCallbackObj = WlanCallbackServiceGet();
46    ASSERT_TRUE(g_wlanObj != nullptr);
47    ASSERT_TRUE(g_wlanCallbackObj != nullptr);
48}
49
50void HdfWifiDirectTest::TearDownTestCase()
51{
52    IWlanInterfaceReleaseInstance(WLAN_SERVICE_NAME, g_wlanObj, true);
53    WlanCallbackServiceRelease(g_wlanCallbackObj);
54}
55
56void HdfWifiDirectTest::SetUp()
57{
58}
59
60void HdfWifiDirectTest::TearDown()
61{
62}
63
64/**
65 * @tc.name: GetSupportFeatureTest_001
66 * @tc.desc: Wifi hdi get support feature function test
67 * @tc.type: FUNC
68 * @tc.require:
69 */
70HWTEST_F(HdfWifiDirectTest, GetSupportFeatureTest_001, TestSize.Level1)
71{
72    uint8_t supType[PROTOCOL_80211_IFTYPE_NUM + 1] = {0};
73    uint32_t supTypeLenInvalid = 6;
74
75    int32_t rc = g_wlanObj->GetSupportFeature(g_wlanObj, nullptr, &supTypeLenInvalid);
76    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
77    rc = g_wlanObj->GetSupportFeature(g_wlanObj, supType, nullptr);
78    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
79    rc = g_wlanObj->GetSupportFeature(g_wlanObj, supType, &supTypeLenInvalid);
80    ASSERT_EQ(rc, HDF_FAILURE);
81}
82
83/**
84 * @tc.name: GetSupportComboTest_002
85 * @tc.desc: Wifi hdi get support combo function test
86 * @tc.type: FUNC
87 * @tc.require:
88 */
89HWTEST_F(HdfWifiDirectTest, GetSupportComboTest_002, TestSize.Level1)
90{
91    uint64_t combo[DEFAULT_COMBO_SIZE] = {0};
92
93    int32_t rc = g_wlanObj->GetSupportCombo(g_wlanObj, nullptr);
94    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
95    rc = g_wlanObj->GetSupportCombo(g_wlanObj, combo);
96    ASSERT_EQ(rc, HDF_FAILURE);
97}
98
99/**
100 * @tc.name: CreateFeatureTest_003
101 * @tc.desc: Wifi hdi create feature function test
102 * @tc.type: FUNC
103 * @tc.require:
104 */
105HWTEST_F(HdfWifiDirectTest, CreateFeatureTest_003, TestSize.Level1)
106{
107    struct HdfFeatureInfo ifeature;
108    int32_t wlanType = PROTOCOL_80211_IFTYPE_AP;
109
110    (void)memset_s(&ifeature, sizeof(struct HdfFeatureInfo), 0, sizeof(struct HdfFeatureInfo));
111    int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, nullptr);
112    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
113    rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
114    ASSERT_EQ(rc, HDF_FAILURE);
115
116    wlanType = PROTOCOL_80211_IFTYPE_STATION;
117    rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
118    ASSERT_EQ(rc, HDF_FAILURE);
119
120    wlanType = PROTOCOL_80211_IFTYPE_P2P_DEVICE;
121    rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
122    ASSERT_EQ(rc, HDF_FAILURE);
123}
124
125/**
126 * @tc.name: DestroyFeatureTest_004
127 * @tc.desc: Wifi hdi destroy feature function test
128 * @tc.type: FUNC
129 * @tc.require:
130 */
131HWTEST_F(HdfWifiDirectTest, DestroyFeatureTest_004, TestSize.Level1)
132{
133    struct HdfFeatureInfo ifeature;
134    string ifName = "wlan0";
135
136    (void)memset_s(&ifeature, sizeof(struct HdfFeatureInfo), 0, sizeof(struct HdfFeatureInfo));
137    int32_t rc = g_wlanObj->DestroyFeature(g_wlanObj, nullptr);
138    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
139    ifeature.ifName = nullptr;
140    rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
141    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
142    ifeature.ifName = const_cast<char*>(ifName.c_str());
143    ifeature.type = PROTOCOL_80211_IFTYPE_AP;
144    rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
145    ASSERT_EQ(rc, HDF_FAILURE);
146    ifeature.type = PROTOCOL_80211_IFTYPE_STATION;
147    rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
148    ASSERT_EQ(rc, HDF_FAILURE);
149    ifeature.type = PROTOCOL_80211_IFTYPE_P2P_DEVICE;
150    rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
151    ASSERT_EQ(rc, HDF_FAILURE);
152}
153
154/**
155 * @tc.name: GetAssociatedStasTest_005
156 * @tc.desc: Wifi hdi get associated stas function test
157 * @tc.type: FUNC
158 * @tc.require:
159 */
160HWTEST_F(HdfWifiDirectTest, GetAssociatedStasTest_005, TestSize.Level1)
161{
162    struct HdfFeatureInfo ifeature;
163    struct HdfStaInfo staInfo[WLAN_MAX_NUM_STA_WITH_AP] = {{0}};
164    uint32_t staInfoLen = WLAN_MAX_NUM_STA_WITH_AP;
165    uint32_t num = 0;
166    string ifName = "wlan0";
167
168    (void)memset_s(&ifeature, sizeof(struct HdfFeatureInfo), 0, sizeof(struct HdfFeatureInfo));
169    int32_t rc = g_wlanObj->GetAssociatedStas(g_wlanObj, nullptr, staInfo, &staInfoLen, &num);
170    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
171    ifeature.ifName = nullptr;
172    rc = g_wlanObj->GetAssociatedStas(g_wlanObj, &ifeature, staInfo, &staInfoLen, &num);
173    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
174    ifeature.ifName = const_cast<char*>(ifName.c_str());
175    rc = g_wlanObj->GetAssociatedStas(g_wlanObj, &ifeature, nullptr, &staInfoLen, &num);
176    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
177    rc = g_wlanObj->GetAssociatedStas(g_wlanObj, &ifeature, staInfo, nullptr, &num);
178    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
179    rc = g_wlanObj->GetAssociatedStas(g_wlanObj, &ifeature, staInfo, &staInfoLen, nullptr);
180    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
181    rc = g_wlanObj->GetAssociatedStas(g_wlanObj, &ifeature, staInfo, &staInfoLen, &num);
182    ASSERT_EQ(rc, HDF_FAILURE);
183}
184
185/**
186 * @tc.name: GetChipIdTest_006
187 * @tc.desc: Wifi hdi get chip id function test
188 * @tc.type: FUNC
189 * @tc.require:
190 */
191HWTEST_F(HdfWifiDirectTest, GetChipIdTest_006, TestSize.Level1)
192{
193    struct HdfFeatureInfo ifeature;
194    uint8_t chipId = 0;
195    string ifName = "wlan0";
196
197    (void)memset_s(&ifeature, sizeof(struct HdfFeatureInfo), 0, sizeof(struct HdfFeatureInfo));
198    int32_t rc = g_wlanObj->GetChipId(g_wlanObj, nullptr, &chipId);
199    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
200    ifeature.ifName = nullptr;
201    rc = g_wlanObj->GetChipId(g_wlanObj, &ifeature, &chipId);
202    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
203    ifeature.ifName = const_cast<char*>(ifName.c_str());
204    rc = g_wlanObj->GetChipId(g_wlanObj, &ifeature, nullptr);
205    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
206    rc = g_wlanObj->GetChipId(g_wlanObj, &ifeature, &chipId);
207    ASSERT_EQ(rc, HDF_FAILURE);
208}
209
210/**
211 * @tc.name: GetDeviceMacAddressTest_007
212 * @tc.desc: Wifi hdi get device mac addr function test on STA feature
213 * @tc.type: FUNC
214 * @tc.require:
215 */
216HWTEST_F(HdfWifiDirectTest, GetDeviceMacAddressTest_007, TestSize.Level1)
217{
218    struct HdfFeatureInfo ifeature;
219    uint8_t mac[ETH_ADDR_LEN] = {0};
220    uint32_t macLen = ETH_ADDR_LEN;
221    string ifName = "wlan0";
222
223    (void)memset_s(&ifeature, sizeof(struct HdfFeatureInfo), 0, sizeof(struct HdfFeatureInfo));
224    int32_t rc = g_wlanObj->GetDeviceMacAddress(g_wlanObj, nullptr, mac, &macLen, ETH_ADDR_LEN);
225    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
226    ifeature.ifName = nullptr;
227    rc = g_wlanObj->GetDeviceMacAddress(g_wlanObj, &ifeature, mac, &macLen, ETH_ADDR_LEN);
228    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
229    ifeature.ifName = const_cast<char*>(ifName.c_str());
230    rc = g_wlanObj->GetDeviceMacAddress(g_wlanObj, &ifeature, nullptr, &macLen, ETH_ADDR_LEN);
231    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
232    rc = g_wlanObj->GetDeviceMacAddress(g_wlanObj, &ifeature, mac, nullptr, ETH_ADDR_LEN);
233    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
234    rc = g_wlanObj->GetDeviceMacAddress(g_wlanObj, &ifeature, mac, &macLen, ETH_ADDR_LEN);
235    ASSERT_EQ(rc, HDF_FAILURE);
236}
237
238/**
239 * @tc.name: GetFeatureByIfNameTest_008
240 * @tc.desc: Wifi hdi get feature by ifname function test
241 * @tc.type: FUNC
242 * @tc.require: AR000H603L
243 */
244HWTEST_F(HdfWifiDirectTest, GetFeatureByIfNameTest_008, TestSize.Level1)
245{
246    struct HdfFeatureInfo ifeature;
247    const char *ifName = "wlan0";
248
249    (void)memset_s(&ifeature, sizeof(struct HdfFeatureInfo), 0, sizeof(struct HdfFeatureInfo));
250    int32_t rc = g_wlanObj->GetFeatureByIfName(g_wlanObj, nullptr, &ifeature);
251    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
252    rc = g_wlanObj->GetFeatureByIfName(g_wlanObj, ifName, nullptr);
253    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
254    rc = g_wlanObj->GetFeatureByIfName(g_wlanObj, ifName, &ifeature);
255    ASSERT_EQ(rc, HDF_FAILURE);
256}
257
258/**
259 * @tc.name: GetFeatureTypeTest_009
260 * @tc.desc: Wifi hdi get feature type function test on STA feature
261 * @tc.type: FUNC
262 * @tc.require:
263 */
264HWTEST_F(HdfWifiDirectTest, GetFeatureTypeTest_009, TestSize.Level1)
265{
266    struct HdfFeatureInfo ifeature;
267    int32_t featureType;
268
269    (void)memset_s(&ifeature, sizeof(struct HdfFeatureInfo), 0, sizeof(struct HdfFeatureInfo));
270    int32_t rc = g_wlanObj->GetFeatureType(g_wlanObj, nullptr, &featureType);
271    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
272    rc = g_wlanObj->GetFeatureType(g_wlanObj, &ifeature, nullptr);
273    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
274    rc = g_wlanObj->GetFeatureType(g_wlanObj, &ifeature, &featureType);
275    ASSERT_EQ(rc, HDF_FAILURE);
276}
277
278/**
279 * @tc.name: GetFreqsWithBandTest_010
280 * @tc.desc: Wifi hdi get freqs function test on STA feature
281 * @tc.type: FUNC
282 * @tc.require:
283 */
284HWTEST_F(HdfWifiDirectTest, GetFreqsWithBandTest_010, TestSize.Level1)
285{
286    struct HdfFeatureInfo ifeature;
287    struct HdfWifiInfo wifiInfo;
288    int32_t freq[WLAN_FREQ_MAX_NUM] = {0};
289    uint32_t freqLen = WLAN_FREQ_MAX_NUM;
290    wifiInfo.band = IEEE80211_BAND_2GHZ;
291    wifiInfo.size = WLAN_FREQ_MAX_NUM;
292    string ifName = "wlan0";
293
294    (void)memset_s(&ifeature, sizeof(struct HdfFeatureInfo), 0, sizeof(struct HdfFeatureInfo));
295    int32_t rc = g_wlanObj->GetFreqsWithBand(g_wlanObj, nullptr, &wifiInfo, freq, &freqLen);
296    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
297    ifeature.ifName = nullptr;
298    rc = g_wlanObj->GetFreqsWithBand(g_wlanObj, &ifeature, &wifiInfo, freq, &freqLen);
299    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
300    ifeature.ifName = const_cast<char*>(ifName.c_str());
301    rc = g_wlanObj->GetFreqsWithBand(g_wlanObj, &ifeature, nullptr, freq, &freqLen);
302    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
303    rc = g_wlanObj->GetFreqsWithBand(g_wlanObj, &ifeature, &wifiInfo, nullptr, &freqLen);
304    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
305    rc = g_wlanObj->GetFreqsWithBand(g_wlanObj, &ifeature, &wifiInfo, freq, nullptr);
306    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
307    rc = g_wlanObj->GetFreqsWithBand(g_wlanObj, &ifeature, &wifiInfo, freq, &freqLen);
308    ASSERT_EQ(rc, HDF_FAILURE);
309}
310
311/**
312 * @tc.name: GetChipIdTest_011
313 * @tc.desc: Wifi hdi get chip id function test on STA feature
314 * @tc.type: FUNC
315 * @tc.require:
316 */
317HWTEST_F(HdfWifiDirectTest, GetChipIdTest_011, TestSize.Level1)
318{
319    uint8_t chipId = 0;
320    uint32_t num = 0;
321    char ifNames[IFNAMSIZ] = {0};
322
323    int32_t rc = g_wlanObj->GetIfNamesByChipId(g_wlanObj, chipId, nullptr, IFNAMSIZ, &num);
324    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
325    rc = g_wlanObj->GetIfNamesByChipId(g_wlanObj, chipId, ifNames, IFNAMSIZ, nullptr);
326    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
327    rc = g_wlanObj->GetIfNamesByChipId(g_wlanObj, chipId, ifNames, IFNAMSIZ, &num);
328    ASSERT_EQ(rc, HDF_FAILURE);
329}
330
331/**
332 * @tc.name: GetNetworkIfaceNameTest_012
333 * @tc.desc: Wifi hdi get network interface name function test on STA feature
334 * @tc.type: FUNC
335 * @tc.require:
336 */
337HWTEST_F(HdfWifiDirectTest, GetNetworkIfaceNameTest_012, TestSize.Level1)
338{
339    struct HdfFeatureInfo ifeature;
340    char ifNames[IFNAMSIZ] = {0};
341    string ifName = "wlan0";
342
343    (void)memset_s(&ifeature, sizeof(struct HdfFeatureInfo), 0, sizeof(struct HdfFeatureInfo));
344    int32_t rc = g_wlanObj->GetNetworkIfaceName(g_wlanObj, nullptr, ifNames, IFNAMSIZ);
345    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
346    ifeature.ifName = nullptr;
347    rc = g_wlanObj->GetNetworkIfaceName(g_wlanObj, &ifeature, ifNames, IFNAMSIZ);
348    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
349    ifeature.ifName = const_cast<char*>(ifName.c_str());
350    rc = g_wlanObj->GetNetworkIfaceName(g_wlanObj, &ifeature, nullptr, IFNAMSIZ);
351    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
352    rc = g_wlanObj->GetNetworkIfaceName(g_wlanObj, &ifeature, ifNames, IFNAMSIZ);
353    ASSERT_EQ(rc, HDF_FAILURE);
354}
355
356/**
357 * @tc.name: RegisterEventCallbackTest_013
358 * @tc.desc: Wifi hdi register event call back function test
359 * @tc.type: FUNC
360 * @tc.require:
361 */
362HWTEST_F(HdfWifiDirectTest, RegisterEventCallbackTest_013, TestSize.Level1)
363{
364    const char *ifName = "wlan0";
365
366    int32_t rc = g_wlanObj->RegisterEventCallback(g_wlanObj, nullptr, ifName);
367    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
368    rc = g_wlanObj->RegisterEventCallback(g_wlanObj, g_wlanCallbackObj, nullptr);
369    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
370    rc = g_wlanObj->RegisterEventCallback(g_wlanObj, g_wlanCallbackObj, ifName);
371    ASSERT_EQ(rc, HDF_FAILURE);
372}
373
374/**
375 * @tc.name: ResetDriverTest_014
376 * @tc.desc: Wifi hdi reset driver function test
377 * @tc.type: FUNC
378 * @tc.require:
379 */
380HWTEST_F(HdfWifiDirectTest, ResetDriverTest_014, TestSize.Level1)
381{
382    const char *ifName = "wlan0";
383    uint8_t chipId = 0;
384
385    int32_t rc = g_wlanObj->ResetDriver(g_wlanObj, chipId, nullptr);
386    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
387    rc = g_wlanObj->ResetDriver(g_wlanObj, chipId, ifName);
388    ASSERT_EQ(rc, HDF_FAILURE);
389}
390
391/**
392 * @tc.name: StartScanTest_015
393 * @tc.desc: Wifi hdi start scan function test
394 * @tc.type: FUNC
395 * @tc.require:
396 */
397HWTEST_F(HdfWifiDirectTest, StartScanTest_015, TestSize.Level1)
398{
399    struct HdfFeatureInfo ifeature;
400    struct HdfWifiScan scan = {0};
401    string ifName = "wlan0";
402
403    (void)memset_s(&ifeature, sizeof(struct HdfFeatureInfo), 0, sizeof(struct HdfFeatureInfo));
404    int32_t rc = g_wlanObj->StartScan(g_wlanObj, nullptr, &scan);
405    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
406    ifeature.ifName = nullptr;
407    rc = g_wlanObj->StartScan(g_wlanObj, &ifeature, &scan);
408    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
409    ifeature.ifName = const_cast<char*>(ifName.c_str());
410    rc = g_wlanObj->StartScan(g_wlanObj, &ifeature, nullptr);
411    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
412    rc = g_wlanObj->StartScan(g_wlanObj, &ifeature, &scan);
413    ASSERT_EQ(rc, HDF_FAILURE);
414}
415
416/**
417 * @tc.name: UnregisterEventCallbackTest_016
418 * @tc.desc: Wifi hdi unreister event call back function test
419 * @tc.type: FUNC
420 * @tc.require:
421 */
422HWTEST_F(HdfWifiDirectTest, UnregisterEventCallbackTest_016, TestSize.Level1)
423{
424    const char *ifName = "wlan0";
425
426    int32_t rc = g_wlanObj->UnregisterEventCallback(g_wlanObj, nullptr, ifName);
427    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
428    rc = g_wlanObj->UnregisterEventCallback(g_wlanObj, g_wlanCallbackObj, nullptr);
429    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
430    rc = g_wlanObj->UnregisterEventCallback(g_wlanObj, g_wlanCallbackObj, ifName);
431    ASSERT_EQ(rc, HDF_FAILURE);
432}
433
434/**
435 * @tc.name: SetCountryCodeTest_017
436 * @tc.desc: Wifi hdi set country code function test
437 * @tc.type: FUNC
438 * @tc.require:
439 */
440HWTEST_F(HdfWifiDirectTest, SetCountryCodeTest_017, TestSize.Level1)
441{
442    const char *code = "CN";
443    struct HdfFeatureInfo ifeature;
444    const char *codeDigital = "99";
445    uint32_t size = 2;
446    string ifName = "wlan0";
447
448    (void)memset_s(&ifeature, sizeof(struct HdfFeatureInfo), 0, sizeof(struct HdfFeatureInfo));
449    int32_t rc = g_wlanObj->SetCountryCode(g_wlanObj, nullptr, codeDigital, size);
450    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
451    ifeature.ifName = nullptr;
452    rc = g_wlanObj->SetCountryCode(g_wlanObj, &ifeature, code, size);
453    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
454    ifeature.ifName = const_cast<char*>(ifName.c_str());
455    rc = g_wlanObj->SetCountryCode(g_wlanObj, &ifeature, nullptr, size);
456    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
457    rc = g_wlanObj->SetCountryCode(g_wlanObj, &ifeature, code, size);
458    ASSERT_EQ(rc, HDF_FAILURE);
459}
460
461/**
462 * @tc.name: SetMacAddressTest_018
463 * @tc.desc: Wifi hdi set mac addr function test on STA feature
464 * @tc.type: FUNC
465 * @tc.require:
466 */
467HWTEST_F(HdfWifiDirectTest, SetMacAddressTest_018, TestSize.Level1)
468{
469    uint8_t mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
470    struct HdfFeatureInfo ifeature;
471    uint32_t macLen = ETH_ADDR_LEN;
472    string ifName = "wlan0";
473
474    (void)memset_s(&ifeature, sizeof(struct HdfFeatureInfo), 0, sizeof(struct HdfFeatureInfo));
475    int32_t rc = g_wlanObj->SetMacAddress(g_wlanObj, nullptr, mac, macLen);
476    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
477    ifeature.ifName = nullptr;
478    rc = g_wlanObj->SetMacAddress(g_wlanObj, &ifeature, mac, macLen);
479    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
480    ifeature.ifName = const_cast<char*>(ifName.c_str());
481    rc = g_wlanObj->SetMacAddress(g_wlanObj, &ifeature, nullptr, macLen);
482    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
483    rc = g_wlanObj->SetMacAddress(g_wlanObj, &ifeature, mac, macLen);
484    ASSERT_EQ(rc, HDF_FAILURE);
485}
486
487/**
488 * @tc.name: SetScanningMacAddressTest_019
489 * @tc.desc: Wifi hdi set scanning mac addr function test
490 * @tc.type: FUNC
491 * @tc.require:
492 */
493HWTEST_F(HdfWifiDirectTest, SetScanningMacAddressTest_019, TestSize.Level1)
494{
495    struct HdfFeatureInfo ifeature;
496    uint8_t scanMac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
497    uint32_t macLen = ETH_ADDR_LEN;
498    string ifName = "wlan0";
499
500    (void)memset_s(&ifeature, sizeof(struct HdfFeatureInfo), 0, sizeof(struct HdfFeatureInfo));
501    int32_t rc = g_wlanObj->SetScanningMacAddress(g_wlanObj, nullptr, scanMac, macLen);
502    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
503    ifeature.ifName = nullptr;
504    rc = g_wlanObj->SetScanningMacAddress(g_wlanObj, &ifeature, scanMac, macLen);
505    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
506    ifeature.ifName = const_cast<char*>(ifName.c_str());
507    rc = g_wlanObj->SetScanningMacAddress(g_wlanObj, &ifeature, nullptr, macLen);
508    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
509    rc = g_wlanObj->SetScanningMacAddress(g_wlanObj, &ifeature, scanMac, macLen);
510    ASSERT_EQ(rc, HDF_FAILURE);
511}
512
513/**
514 * @tc.name: SetTxPowerTest_020
515 * @tc.desc: Wifi hdi set tx power function test on STA feature
516 * @tc.type: FUNC
517 * @tc.require:
518 */
519HWTEST_F(HdfWifiDirectTest, SetTxPowerTest_020, TestSize.Level1)
520{
521    struct HdfFeatureInfo ifeature;
522    int32_t power = WLAN_TX_POWER;
523    string ifName = "wlan0";
524
525    (void)memset_s(&ifeature, sizeof(struct HdfFeatureInfo), 0, sizeof(struct HdfFeatureInfo));
526    int32_t rc = g_wlanObj->SetTxPower(g_wlanObj, nullptr, power);
527    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
528    ifeature.ifName = nullptr;
529    rc = g_wlanObj->SetTxPower(g_wlanObj, &ifeature, power);
530    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
531    ifeature.ifName = const_cast<char*>(ifName.c_str());
532    rc = g_wlanObj->SetTxPower(g_wlanObj, &ifeature, power);
533    ASSERT_EQ(rc, HDF_FAILURE);
534}
535
536/**
537 * @tc.name: GetNetdevInfoTest_021
538 * @tc.desc: Wifi hdi get netdev info function test
539 * @tc.type: FUNC
540 * @tc.require:
541 */
542HWTEST_F(HdfWifiDirectTest, GetNetdevInfoTest_021, TestSize.Level1)
543{
544    int32_t rc;
545    struct HdfNetDeviceInfoResult netDeviceInfoResult;
546
547    (void)memset_s(
548        &netDeviceInfoResult, sizeof(struct HdfNetDeviceInfoResult), 0, sizeof(struct HdfNetDeviceInfoResult));
549    rc = g_wlanObj->GetNetDevInfo(g_wlanObj, (struct HdfNetDeviceInfoResult *)&netDeviceInfoResult);
550    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
551    rc = g_wlanObj->GetNetDevInfo(g_wlanObj, nullptr);
552    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
553}
554
555/**
556 * @tc.name: GetPowerModeTest_022
557 * @tc.desc: Wifi hdi get power mode function test
558 * @tc.type: FUNC
559 * @tc.require:
560 */
561HWTEST_F(HdfWifiDirectTest, GetPowerModeTest_022, TestSize.Level1)
562{
563    struct HdfFeatureInfo ifeature;
564    uint8_t mode = 0;
565    string ifName = "wlan0";
566
567    (void)memset_s(&ifeature, sizeof(struct HdfFeatureInfo), 0, sizeof(struct HdfFeatureInfo));
568    int32_t rc = g_wlanObj->GetPowerMode(g_wlanObj, nullptr, &mode);
569    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
570    ifeature.ifName = nullptr;
571    rc = g_wlanObj->GetPowerMode(g_wlanObj, &ifeature, &mode);
572    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
573    ifeature.ifName = const_cast<char*>(ifName.c_str());
574    rc = g_wlanObj->GetPowerMode(g_wlanObj, &ifeature, nullptr);
575    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
576    rc = g_wlanObj->GetPowerMode(g_wlanObj, &ifeature, &mode);
577    ASSERT_EQ(rc, HDF_FAILURE);
578}
579
580/**
581 * @tc.name: SetPowerModeTest_023
582 * @tc.desc: Wifi hdi set power mode function test
583 * @tc.type: FUNC
584 * @tc.require:
585 */
586HWTEST_F(HdfWifiDirectTest, SetPowerModeTest_023, TestSize.Level1)
587{
588    struct HdfFeatureInfo ifeature;
589    uint8_t mode = WIFI_POWER_MODE_SLEEPING;
590    string ifName = "wlan0";
591
592    (void)memset_s(&ifeature, sizeof(struct HdfFeatureInfo), 0, sizeof(struct HdfFeatureInfo));
593    int32_t rc = g_wlanObj->SetPowerMode(g_wlanObj, nullptr, mode);
594    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
595    ifeature.ifName = nullptr;
596    rc = g_wlanObj->SetPowerMode(g_wlanObj, &ifeature, mode);
597    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
598    ifeature.ifName = const_cast<char*>(ifName.c_str());
599    rc = g_wlanObj->SetPowerMode(g_wlanObj, &ifeature, mode);
600    ASSERT_EQ(rc, HDF_FAILURE);
601}
602
603/**
604 * @tc.name: SetProjectionScreenParam_024
605 * @tc.desc: Wifi hdi set paramters to optimize projectino screen function test
606 * @tc.type: FUNC
607 * @tc.require:
608 */
609HWTEST_F(HdfWifiDirectTest, SetProjectionScreenParam_024, TestSize.Level1)
610{
611    const char *ifName = "wlan0";
612    int32_t rc;
613    struct ProjectionScreenCmdParam param;
614
615    (void)memset_s(&param, sizeof(struct ProjectionScreenCmdParam), 0, sizeof(struct ProjectionScreenCmdParam));
616    rc = g_wlanObj->SetProjectionScreenParam(g_wlanObj, nullptr, &param);
617    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
618    rc = g_wlanObj->SetProjectionScreenParam(g_wlanObj, ifName, nullptr);
619    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
620    rc = g_wlanObj->SetProjectionScreenParam(g_wlanObj, ifName, &param);
621    ASSERT_EQ(rc, HDF_FAILURE);
622}
623
624/**
625 * @tc.name: GetStaInfo_025
626 * @tc.desc: Wifi hdi get station information function test
627 * @tc.type: FUNC
628 * @tc.require:
629 */
630HWTEST_F(HdfWifiDirectTest, GetStaInfo_025, TestSize.Level1)
631{
632    const char *ifName = "wlan0";
633    int32_t rc;
634    struct WifiStationInfo info;
635    uint8_t mac[ETH_ADDR_LEN] = {0};
636
637    (void)memset_s(&info, sizeof(struct WifiStationInfo), 0, sizeof(struct WifiStationInfo));
638    rc = g_wlanObj->GetStaInfo(g_wlanObj, nullptr, &info, mac, ETH_ADDR_LEN);
639    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
640    rc = g_wlanObj->GetStaInfo(g_wlanObj, ifName, nullptr, mac, ETH_ADDR_LEN);
641    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
642    rc = g_wlanObj->GetStaInfo(g_wlanObj, ifName, &info, nullptr, ETH_ADDR_LEN);
643    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
644    rc = g_wlanObj->GetStaInfo(g_wlanObj, ifName, &info, mac, ETH_ADDR_LEN);
645    ASSERT_EQ(rc, HDF_FAILURE);
646}
647
648/**
649 * @tc.name: GetApBandwidthTest_026
650 * @tc.desc: Wifi hdi get ap bandwidth info function test
651 * @tc.type: FUNC
652 * @tc.require:
653 */
654HWTEST_F(HdfWifiDirectTest, GetApBandwidthTest_026, TestSize.Level1)
655{
656    int32_t rc;
657    uint8_t bandwidth = 0;
658    const char *ifName = "wlan0";
659
660    rc = g_wlanObj->GetApBandwidth(g_wlanObj, nullptr, &bandwidth);
661    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
662    rc = g_wlanObj->GetApBandwidth(g_wlanObj, ifName, nullptr);
663    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
664    rc = g_wlanObj->GetApBandwidth(g_wlanObj, ifName, &bandwidth);
665    ASSERT_EQ(rc, HDF_FAILURE);
666}
667
668/**
669 * @tc.name: ResetToFactoryMacAddressTest_027
670 * @tc.desc: Wifi hdi reset mac address function test
671 * @tc.type: FUNC
672 * @tc.require:
673 */
674HWTEST_F(HdfWifiDirectTest, ResetToFactoryMacAddressTest_027, TestSize.Level1)
675{
676    int32_t rc;
677    const char *ifName = "wlan0";
678
679    rc = g_wlanObj->ResetToFactoryMacAddress(g_wlanObj, nullptr);
680    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
681    rc = g_wlanObj->ResetToFactoryMacAddress(g_wlanObj, ifName);
682    ASSERT_EQ(rc, HDF_FAILURE);
683}
684
685
686/**
687 * @tc.name: SendActionFrameTest_028
688 * @tc.desc: Wifi hdi send action frame function test
689 * @tc.type: FUNC
690 * @tc.require:
691 */
692HWTEST_F(HdfWifiDirectTest, SendActionFrameTest_028, TestSize.Level1)
693{
694    int32_t freq = WLAN_TX_POWER;
695    uint32_t frameDataLen = DEFAULT_COMBO_SIZE;
696    uint8_t frameData[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
697    const char *ifName = "wlan0";
698
699    int32_t rc = g_wlanObj->SendActionFrame(g_wlanObj, nullptr, freq, frameData, frameDataLen);
700    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
701    rc = g_wlanObj->SendActionFrame(g_wlanObj, ifName, 0, frameData, frameDataLen);
702    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
703    rc = g_wlanObj->SendActionFrame(g_wlanObj, ifName, freq, nullptr, frameDataLen);
704    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
705    rc = g_wlanObj->SendActionFrame(g_wlanObj, ifName, freq, frameData, 0);
706    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
707    rc = g_wlanObj->SendActionFrame(g_wlanObj, ifName, freq, frameData, frameDataLen);
708    ASSERT_EQ(rc, HDF_FAILURE);
709}
710
711/**
712 * @tc.name: RegisterActionFrameReceiverTest_029
713 * @tc.desc: Wifi hdi reset mac address function test
714 * @tc.type: FUNC
715 * @tc.require:
716 */
717HWTEST_F(HdfWifiDirectTest, RegisterActionFrameReceiverTest_029, TestSize.Level1)
718{
719    int32_t rc;
720    uint8_t match [ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
721    uint32_t matchLen = DEFAULT_COMBO_SIZE;
722    const char *ifName = "wlan0";
723
724    rc = g_wlanObj->RegisterActionFrameReceiver(g_wlanObj, nullptr, match, matchLen);
725    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
726    rc = g_wlanObj->RegisterActionFrameReceiver(g_wlanObj, ifName, nullptr, matchLen);
727    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
728    rc = g_wlanObj->RegisterActionFrameReceiver(g_wlanObj, ifName, match, 0);
729    ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
730    rc = g_wlanObj->RegisterActionFrameReceiver(g_wlanObj, ifName, match, matchLen);
731    ASSERT_EQ(rc, HDF_FAILURE);
732}
733};
734