1 /*
2  * Copyright (c) 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 #include "gtest/gtest.h"
16 #include <securec.h>
17 
18 #include "softbus_def.h"
19 #include "softbus_errcode.h"
20 #include "softbus_wifi_api_adapter.h"
21 #include "wifi_mock.h"
22 
23 namespace OHOS {
24 using namespace testing::ext;
25 using namespace testing;
26 #define TEST_SSID           "321654761321465"
27 #define TEST_BSSID          "67251"
28 #define TEST_SHAREKEY       "468721652"
29 #define TEST_SER_TYPE       2
30 #define TEST_IS_HIDDEN_SSID 0
31 #define TEST_CONFIG_SIZE    1
32 class AdapterDsoftbusWifiTest : public testing::Test {
33 protected:
34     static void SetUpTestCase(void);
35     static void TearDownTestCase(void);
36     void SetUp();
37     void TearDown();
38 };
SetUpTestCase(void)39 void AdapterDsoftbusWifiTest::SetUpTestCase(void) { }
TearDownTestCase(void)40 void AdapterDsoftbusWifiTest::TearDownTestCase(void) { }
SetUp()41 void AdapterDsoftbusWifiTest::SetUp() { }
TearDown()42 void AdapterDsoftbusWifiTest::TearDown() { }
OnSoftBusWifiScanResult(int state,int size)43 void OnSoftBusWifiScanResult(int state, int size) { }
44 /*
45  * @tc.name: SoftBusGetWifiDeviceConfig
46  * @tc.desc: softbus wifi test
47  * @tc.type: FUNC
48  * @tc.require:
49  */
50 HWTEST_F(AdapterDsoftbusWifiTest, SoftBusGetWifiDeviceConfigTest001, TestSize.Level1)
51 {
52     SoftBusWifiDevConf configList;
53     NiceMock<WifiInterfaceMock> wifiMock;
54     ON_CALL(wifiMock, GetDeviceConfigs).WillByDefault(Return(WIFI_SUCCESS));
55     (void)memset_s(&configList, sizeof(SoftBusWifiDevConf), 0, sizeof(SoftBusWifiDevConf));
56     (void)strcpy_s(configList.ssid, sizeof(TEST_SSID), TEST_SSID);
57     (void)memcpy_s(configList.bssid, sizeof(TEST_BSSID), TEST_BSSID, sizeof(TEST_BSSID));
58     (void)strcpy_s(configList.preSharedKey, sizeof(TEST_SHAREKEY), TEST_SHAREKEY);
59     configList.securityType = TEST_SER_TYPE;
60     configList.isHiddenSsid = TEST_IS_HIDDEN_SSID;
61     uint32_t num;
62     int32_t ret = SoftBusGetWifiDeviceConfig(&configList, &num);
63     EXPECT_TRUE(ret == SOFTBUS_OK);
64     EXPECT_CALL(wifiMock, GetDeviceConfigs)
65         .WillOnce(DoAll(SetArgPointee<1>(WIFI_MAX_CONFIG_SIZE + 1), Return(WIFI_SUCCESS)));
66 
67     ret = SoftBusGetWifiDeviceConfig(&configList, &num);
68     EXPECT_TRUE(ret == SOFTBUS_ERR);
69     EXPECT_CALL(wifiMock, GetDeviceConfigs)
70         .WillOnce(DoAll(SetArgPointee<1>(TEST_CONFIG_SIZE), Return(ERROR_WIFI_INVALID_ARGS)));
71     ret = SoftBusGetWifiDeviceConfig(&configList, &num);
72     EXPECT_TRUE(ret == SOFTBUS_ERR);
73     ret = SoftBusGetWifiDeviceConfig(nullptr, &num);
74     EXPECT_TRUE(ret == SOFTBUS_ERR);
75 }
76 
77 /*
78  * @tc.name: SoftBusConnectToDevice
79  * @tc.desc: softbus wifi test
80  * @tc.type: FUNC
81  * @tc.require:
82  */
83 HWTEST_F(AdapterDsoftbusWifiTest, SoftBusConnectToDeviceTest001, TestSize.Level1)
84 {
85     SoftBusWifiDevConf configList;
86     NiceMock<WifiInterfaceMock> wifiMock;
87     ON_CALL(wifiMock, ConnectToDevice).WillByDefault(Return(WIFI_SUCCESS));
88     (void)memset_s(&configList, sizeof(SoftBusWifiDevConf), 0, sizeof(SoftBusWifiDevConf));
89     (void)strcpy_s(configList.ssid, sizeof(TEST_SSID), TEST_SSID);
90     (void)memcpy_s(configList.bssid, sizeof(TEST_BSSID), TEST_BSSID, sizeof(TEST_BSSID));
91     (void)strcpy_s(configList.preSharedKey, sizeof(TEST_SHAREKEY), TEST_SHAREKEY);
92     configList.securityType = TEST_SER_TYPE;
93     configList.isHiddenSsid = TEST_IS_HIDDEN_SSID;
94 
95     int32_t ret = SoftBusConnectToDevice(&configList);
96     EXPECT_TRUE(ret == SOFTBUS_OK);
97     EXPECT_CALL(wifiMock, GetDeviceConfigs).WillRepeatedly(Return(ERROR_WIFI_INVALID_ARGS));
98     ret = SoftBusConnectToDevice(&configList);
99     EXPECT_TRUE(ret == SOFTBUS_OK);
100     ret = SoftBusConnectToDevice(nullptr);
101     EXPECT_TRUE(ret == SOFTBUS_ERR);
102 }
103 
104 /*
105  * @tc.name: SoftBusStartWifiScan
106  * @tc.desc: softbus wifi test
107  * @tc.type: FUNC
108  * @tc.require:
109  */
110 HWTEST_F(AdapterDsoftbusWifiTest, SoftBusStartWifiScanTest001, TestSize.Level1)
111 {
112     NiceMock<WifiInterfaceMock> wifiMock;
113     EXPECT_CALL(wifiMock, Scan).WillOnce(Return(WIFI_SUCCESS)).WillRepeatedly(Return(ERROR_WIFI_INVALID_ARGS));
114     int32_t ret = SoftBusStartWifiScan();
115     EXPECT_TRUE(ret == SOFTBUS_OK);
116     ret = SoftBusStartWifiScan();
117     EXPECT_TRUE(ret == SOFTBUS_ERR);
118 }
119 
120 /*
121  * @tc.name: ScanResultCb
122  * @tc.desc: softbus wifi test
123  * @tc.type: FUNC
124  * @tc.require:
125  */
126 HWTEST_F(AdapterDsoftbusWifiTest, ScanResultCbTest001, TestSize.Level1)
127 {
128     NiceMock<WifiInterfaceMock> wifiMock;
129     ISoftBusScanResult cb = {
130         .onSoftBusWifiScanResult = OnSoftBusWifiScanResult,
131     };
132     EXPECT_CALL(wifiMock, RegisterWifiEvent)
133         .WillOnce(Return(WIFI_SUCCESS))
134         .WillRepeatedly(Return(ERROR_WIFI_INVALID_ARGS));
135     int32_t ret = SoftBusRegisterWifiEvent(&cb);
136     EXPECT_TRUE(ret == SOFTBUS_OK);
137     ret = SoftBusRegisterWifiEvent(nullptr);
138     EXPECT_TRUE(ret == SOFTBUS_OK);
139 }
140 
141 /*
142  * @tc.name: SoftBusGetWifiScanList
143  * @tc.desc: softbus wifi test
144  * @tc.type: FUNC
145  * @tc.require:
146  */
147 HWTEST_F(AdapterDsoftbusWifiTest, SoftBusGetWifiScanListTest001, TestSize.Level1)
148 {
149     NiceMock<WifiInterfaceMock> wifiMock;
150     ON_CALL(wifiMock, GetScanInfoList).WillByDefault(Return(WIFI_SUCCESS));
151     SoftBusWifiScanInfo *result = nullptr;
152     uint32_t size;
153     int32_t ret = SoftBusGetWifiScanList(nullptr, nullptr);
154     EXPECT_TRUE(ret == SOFTBUS_ERR);
155     ret = SoftBusGetWifiScanList(&result, nullptr);
156     EXPECT_TRUE(ret == SOFTBUS_ERR);
157     ret = SoftBusGetWifiScanList(&result, &size);
158     EXPECT_TRUE(ret == SOFTBUS_OK);
159     EXPECT_CALL(wifiMock, GetScanInfoList).WillRepeatedly(Return(ERROR_WIFI_INVALID_ARGS));
160     ret = SoftBusGetWifiScanList(&result, &size);
161     EXPECT_TRUE(ret == SOFTBUS_ERR);
162 }
163 
164 /*
165  * @tc.name: SoftBusUnRegisterWifiEvent
166  * @tc.desc: softbus wifi test
167  * @tc.type: FUNC
168  * @tc.require:
169  */
170 HWTEST_F(AdapterDsoftbusWifiTest, SoftBusUnRegisterWifiEventTest001, TestSize.Level1)
171 {
172     NiceMock<WifiInterfaceMock> wifiMock;
173 
174     ISoftBusScanResult cb = {
175         .onSoftBusWifiScanResult = OnSoftBusWifiScanResult,
176     };
177     EXPECT_CALL(wifiMock, UnRegisterWifiEvent)
178         .WillOnce(Return(WIFI_SUCCESS))
179         .WillRepeatedly(Return(ERROR_WIFI_INVALID_ARGS));
180     int32_t ret = SoftBusUnRegisterWifiEvent(&cb);
181     EXPECT_TRUE(ret == SOFTBUS_OK);
182     ret = SoftBusUnRegisterWifiEvent(nullptr);
183     EXPECT_TRUE(ret == SOFTBUS_ERR);
184 }
185 
186 /*
187  * @tc.name: SoftBusGetChannelListFor5G
188  * @tc.desc: softbus wifi test
189  * @tc.type: FUNC
190  * @tc.require:
191  */
192 HWTEST_F(AdapterDsoftbusWifiTest, SoftBusGetChannelListFor5GTest001, TestSize.Level1)
193 {
194     NiceMock<WifiInterfaceMock> wifiMock;
195     int32_t channelList = TEST_CONFIG_SIZE;
196     int32_t num = TEST_CONFIG_SIZE;
197     EXPECT_CALL(wifiMock, Hid2dGetChannelListFor5G)
198         .WillOnce(Return(WIFI_SUCCESS))
199         .WillRepeatedly(Return(ERROR_WIFI_INVALID_ARGS));
200     int32_t ret = SoftBusGetChannelListFor5G(&channelList, num);
201     EXPECT_TRUE(ret == SOFTBUS_OK);
202     ret = SoftBusGetChannelListFor5G(&channelList, num);
203     EXPECT_TRUE(ret == SOFTBUS_ERR);
204     ret = SoftBusGetChannelListFor5G(nullptr, num);
205     EXPECT_TRUE(ret == SOFTBUS_ERR);
206 }
207 
208 /*
209  * @tc.name: SoftBusGetLinkBand
210  * @tc.desc: softbus wifi test
211  * @tc.type: FUNC
212  * @tc.require:
213  */
214 HWTEST_F(AdapterDsoftbusWifiTest, SoftBusGetLinkBandTest001, TestSize.Level1)
215 {
216     NiceMock<WifiInterfaceMock> wifiMock;
217     WifiLinkedInfo result = {
218         .band = BAND_24G,
219     };
220     WifiLinkedInfo result2 = {
221         .band = BAND_5G,
222     };
223     WifiLinkedInfo result3 = {
224         .band = BAND_UNKNOWN,
225     };
226     EXPECT_CALL(wifiMock, GetLinkedInfo)
227         .WillRepeatedly(DoAll(SetArgPointee<0>(result), Return(ERROR_WIFI_INVALID_ARGS)));
228     int32_t ret = SoftBusGetLinkBand();
229     EXPECT_TRUE(ret == BAND_UNKNOWN);
230     EXPECT_CALL(wifiMock, GetLinkedInfo).WillRepeatedly(DoAll(SetArgPointee<0>(result), Return(WIFI_SUCCESS)));
231     ret = SoftBusGetLinkBand();
232     EXPECT_TRUE(ret == BAND_24G);
233     EXPECT_CALL(wifiMock, GetLinkedInfo).WillRepeatedly(DoAll(SetArgPointee<0>(result2), Return(WIFI_SUCCESS)));
234     ret = SoftBusGetLinkBand();
235     EXPECT_TRUE(ret == BAND_5G);
236     EXPECT_CALL(wifiMock, GetLinkedInfo).WillRepeatedly(DoAll(SetArgPointee<0>(result3), Return(WIFI_SUCCESS)));
237     ret = SoftBusGetLinkBand();
238     EXPECT_TRUE(ret == BAND_UNKNOWN);
239 }
240 
241 /*
242  * @tc.name: SoftBusGetLinkedInfo
243  * @tc.desc: softbus wifi test
244  * @tc.type: FUNC
245  * @tc.require:
246  */
247 HWTEST_F(AdapterDsoftbusWifiTest, SoftBusGetLinkedInfoTest001, TestSize.Level1)
248 {
249     NiceMock<WifiInterfaceMock> wifiMock;
250     SoftBusWifiLinkedInfo info;
251     EXPECT_CALL(wifiMock, GetLinkedInfo).WillOnce(Return(WIFI_SUCCESS)).WillRepeatedly(Return(ERROR_WIFI_INVALID_ARGS));
252     int32_t ret = SoftBusGetLinkedInfo(&info);
253     EXPECT_TRUE(ret == SOFTBUS_OK);
254     ret = SoftBusGetLinkedInfo(&info);
255     EXPECT_TRUE(ret == SOFTBUS_ERR);
256 }
257 
258 /*
259  * @tc.name: SoftBusGetCurrentGroup
260  * @tc.desc: softbus wifi test
261  * @tc.type: FUNC
262  * @tc.require:
263  */
264 HWTEST_F(AdapterDsoftbusWifiTest, SoftBusGetCurrentGroupTest001, TestSize.Level1)
265 {
266     NiceMock<WifiInterfaceMock> wifiMock;
267     SoftBusWifiP2pGroupInfo groupInfo;
268     EXPECT_CALL(wifiMock, GetCurrentGroup)
269         .WillOnce(Return(WIFI_SUCCESS))
270         .WillRepeatedly(Return(ERROR_WIFI_INVALID_ARGS));
271     int32_t ret = SoftBusGetCurrentGroup(&groupInfo);
272     EXPECT_TRUE(ret != SOFTBUS_OK);
273 }
274 
275 /*
276  * @tc.name: SoftBusIsWifiActive
277  * @tc.desc: softbus wifi test
278  * @tc.type: FUNC
279  * @tc.require:
280  */
281 HWTEST_F(AdapterDsoftbusWifiTest, SoftBusIsWifiActiveTest001, TestSize.Level1)
282 {
283     NiceMock<WifiInterfaceMock> wifiMock;
284     EXPECT_CALL(wifiMock, IsWifiActive)
285         .WillOnce(Return(WIFI_STA_ACTIVE))
286         .WillRepeatedly(Return(WIFI_STA_NOT_ACTIVE));
287     bool ret = SoftBusIsWifiActive();
288     EXPECT_TRUE(ret == true);
289     ret = SoftBusIsWifiActive();
290     EXPECT_TRUE(ret == false);
291 }
292 
293 /*
294  * @tc.name: SoftBusGetWifiState
295  * @tc.desc: softbus wifi test
296  * @tc.type: FUNC
297  * @tc.require:
298  */
299 HWTEST_F(AdapterDsoftbusWifiTest, SoftBusGetWifiStateTest001, TestSize.Level1)
300 {
301     WifiDetailState wifiState = STATE_INACTIVE;
302     NiceMock<WifiInterfaceMock> wifiMock;
303     EXPECT_CALL(wifiMock, GetWifiDetailState)
304         .WillOnce(DoAll(SetArgPointee<0>(wifiState), Return(ERROR_WIFI_INVALID_ARGS)));
305     SoftBusWifiDetailState ret = SoftBusGetWifiState();
306     EXPECT_TRUE(ret == SOFTBUS_WIFI_STATE_UNKNOWN);
307 
308     EXPECT_CALL(wifiMock, GetWifiDetailState)
309         .WillOnce(DoAll(SetArgPointee<0>(wifiState), Return(WIFI_SUCCESS)));
310     ret = SoftBusGetWifiState();
311     EXPECT_TRUE(ret == SOFTBUS_WIFI_STATE_INACTIVE);
312 
313     wifiState = STATE_ACTIVATED;
314     EXPECT_CALL(wifiMock, GetWifiDetailState)
315         .WillOnce(DoAll(SetArgPointee<0>(wifiState), Return(WIFI_SUCCESS)));
316     ret = SoftBusGetWifiState();
317     EXPECT_TRUE(ret == SOFTBUS_WIFI_STATE_ACTIVED);
318 
319     wifiState = STATE_SEMI_ACTIVE;
320     EXPECT_CALL(wifiMock, GetWifiDetailState)
321         .WillOnce(DoAll(SetArgPointee<0>(wifiState), Return(WIFI_SUCCESS)));
322     ret = SoftBusGetWifiState();
323     EXPECT_TRUE(ret == SOFTBUS_WIFI_STATE_SEMIACTIVE);
324 }
325 
326 /*
327  * @tc.name: SoftBusIsWifiP2pEnabled
328  * @tc.desc: softbus wifi test
329  * @tc.type: FUNC
330  * @tc.require:
331  */
332 HWTEST_F(AdapterDsoftbusWifiTest, SoftBusIsWifiP2pEnabledTest001, TestSize.Level1)
333 {
334     P2pState stateEnable = P2P_STATE_STARTED;
335     P2pState stateDisable = P2P_STATE_CLOSING;
336     NiceMock<WifiInterfaceMock> wifiMock;
337     EXPECT_CALL(wifiMock, GetP2pEnableStatus)
338         .WillRepeatedly(DoAll(SetArgPointee<0>(stateEnable), Return(ERROR_WIFI_INVALID_ARGS)));
339     bool ret = SoftBusIsWifiP2pEnabled();
340     EXPECT_TRUE(ret == false);
341 
342     EXPECT_CALL(wifiMock, GetP2pEnableStatus)
343         .WillRepeatedly(DoAll(SetArgPointee<0>(stateDisable), Return(WIFI_SUCCESS)));
344     ret = SoftBusIsWifiP2pEnabled();
345     EXPECT_TRUE(ret == false);
346 
347     EXPECT_CALL(wifiMock, GetP2pEnableStatus)
348         .WillRepeatedly(DoAll(SetArgPointee<0>(stateEnable), Return(WIFI_SUCCESS)));
349     ret = SoftBusIsWifiP2pEnabled();
350     EXPECT_TRUE(ret == true);
351 }
352 } // namespace OHOS