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 "wifi_hal_p2p_interface_test.h"
17 #include "securec.h"
18 #include "wifi_log.h"
19 #include "wifi_hal_p2p_interface.h"
20 #include "wifi_p2p_hal.h"
21 #include "mock_wpa_ctrl.h"
22 #include "wifi_hal_common_func.h"
23
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Wifi {
28 static char P2pTestInterface[32] = "wlan0";
29
SetUpTestCase()30 void WifiHalP2pInterfaceTest::SetUpTestCase()
31 {
32 MockInitGlobalCmd();
33 MockInitP2pSupportedCmd();
34 }
35
36 HWTEST_F(WifiHalP2pInterfaceTest, P2pStartTest, TestSize.Level1)
37 {
38 EXPECT_TRUE(P2pStart() == WIFI_HAL_SUCCESS);
39 }
40
41 HWTEST_F(WifiHalP2pInterfaceTest, P2pSetRandomMacTest, TestSize.Level1)
42 {
43 MockSetWpaExpectCmdResponse("DRIVER_FLAGS", "DEDICATED_P2P_DEVICE\n");
44 EXPECT_TRUE(P2pSetRandomMac(0) == WIFI_HAL_SUCCESS);
45 }
46
47 HWTEST_F(WifiHalP2pInterfaceTest, P2pSetDeviceNameTest, TestSize.Level1)
48 {
49 EXPECT_TRUE(P2pSetDeviceName(NULL) == WIFI_HAL_FAILED);
50 EXPECT_TRUE(P2pSetDeviceName("p2p-device") == WIFI_HAL_SUCCESS);
51 }
52
53 HWTEST_F(WifiHalP2pInterfaceTest, P2pSetSsidPostfixNameTest, TestSize.Level1)
54 {
55 EXPECT_TRUE(P2pSetSsidPostfixName(NULL) == WIFI_HAL_FAILED);
56 EXPECT_TRUE(P2pSetSsidPostfixName("p2p-postfix") == WIFI_HAL_SUCCESS);
57 }
58
59 HWTEST_F(WifiHalP2pInterfaceTest, P2pSetWpsDeviceTypeTest, TestSize.Level1)
60 {
61 EXPECT_TRUE(P2pSetWpsDeviceType(NULL) == WIFI_HAL_FAILED);
62 EXPECT_TRUE(P2pSetWpsDeviceType("6-0050F204-1") == WIFI_HAL_SUCCESS);
63 }
64
65 HWTEST_F(WifiHalP2pInterfaceTest, P2pSetWpsConfigMethodsTest, TestSize.Level1)
66 {
67 EXPECT_TRUE(P2pSetWpsConfigMethods(NULL) == WIFI_HAL_FAILED);
68 EXPECT_TRUE(P2pSetWpsConfigMethods("label display push_button keypad") == WIFI_HAL_SUCCESS);
69 }
70
71 HWTEST_F(WifiHalP2pInterfaceTest, P2pGetDeviceAddressTest, TestSize.Level1)
72 {
73 EXPECT_TRUE(P2pGetDeviceAddress(nullptr, 0) == WIFI_HAL_FAILED);
74 MockSetWpaExpectCmdResponse("STATUS", "p2p_device_address=00:00:00:00:00:00\n");
75 char deviceAddress[128] = {0};
76 EXPECT_TRUE(P2pGetDeviceAddress(deviceAddress, 128) == WIFI_HAL_SUCCESS);
77 }
78
79 HWTEST_F(WifiHalP2pInterfaceTest, P2pFlushTest, TestSize.Level1)
80 {
81 MockEraseSupportedCmd("P2P_FLUSH");
82 EXPECT_TRUE(P2pFlush() == WIFI_HAL_FAILED);
83 MockSetWpaExpectCmdResponse("P2P_FLUSH", "OK");
84 EXPECT_TRUE(P2pFlush() == WIFI_HAL_SUCCESS);
85 }
86
87 HWTEST_F(WifiHalP2pInterfaceTest, P2pFlushServiceTest, TestSize.Level1)
88 {
89 EXPECT_TRUE(P2pFlushService() == WIFI_HAL_SUCCESS);
90 }
91
92 HWTEST_F(WifiHalP2pInterfaceTest, P2pSaveConfigTest, TestSize.Level1)
93 {
94 EXPECT_TRUE(P2pSaveConfig() == WIFI_HAL_SUCCESS);
95 }
96
97 HWTEST_F(WifiHalP2pInterfaceTest, P2pSetupWpsPbcTest, TestSize.Level1)
98 {
99 EXPECT_TRUE(P2pSetupWpsPbc(nullptr, nullptr) == WIFI_HAL_FAILED);
100 char bssid[32] = {0};
101 EXPECT_TRUE(P2pSetupWpsPbc(P2pTestInterface, bssid) == WIFI_HAL_SUCCESS);
102 StrSafeCopy(bssid, sizeof(bssid), "dc:f0:9e:9b:06:c5");
103 EXPECT_TRUE(P2pSetupWpsPbc(P2pTestInterface, bssid) == WIFI_HAL_SUCCESS);
104 }
105
106 HWTEST_F(WifiHalP2pInterfaceTest, P2pSetupWpsPinTest, TestSize.Level1)
107 {
108 EXPECT_TRUE(P2pSetupWpsPin(nullptr, nullptr, nullptr, nullptr, 0) == WIFI_HAL_FAILED);
109 char bssid[32] = {0};
110 char pin[32] = {0};
111 char result[32] = {0};
112 EXPECT_TRUE(P2pSetupWpsPin(P2pTestInterface, bssid, pin, result, sizeof(result)) == WIFI_HAL_SUCCESS);
113 StrSafeCopy(pin, sizeof(pin), "12345678");
114 EXPECT_TRUE(P2pSetupWpsPin(P2pTestInterface, bssid, pin, result, sizeof(result)) == WIFI_HAL_SUCCESS);
115 }
116
117 HWTEST_F(WifiHalP2pInterfaceTest, P2pRemoveNetworkTest, TestSize.Level1)
118 {
119 EXPECT_TRUE(P2pRemoveNetwork(0) == WIFI_HAL_SUCCESS);
120 }
121
122 HWTEST_F(WifiHalP2pInterfaceTest, P2pListNetworksTest, TestSize.Level1)
123 {
124 EXPECT_TRUE(P2pListNetworks(nullptr) == WIFI_HAL_FAILED);
125 char replyBuff[] = "network id / ssid / bssid / flags\n"
126 "0\tDIRECT-OHOS\t00:00:00:00:00:00\t[DISABLED][P2P-PERSISTENT]\n";
127 MockSetWpaExpectCmdResponse("LIST_NETWORKS", replyBuff);
128 P2pNetworkList info;
129 ASSERT_TRUE(memset_s(&info, sizeof(info), 0, sizeof(info)) == EOK);
130 EXPECT_TRUE(P2pListNetworks(&info) == WIFI_HAL_SUCCESS);
131 }
132
133 HWTEST_F(WifiHalP2pInterfaceTest, P2PSetGroupIdleTest, TestSize.Level1)
134 {
135 int time = 10;
136 EXPECT_TRUE(P2pSetGroupMaxIdle(NULL, time) == WIFI_HAL_FAILED);
137 EXPECT_TRUE(P2pSetGroupMaxIdle(P2pTestInterface, time) == WIFI_HAL_SUCCESS);
138 }
139
140 HWTEST_F(WifiHalP2pInterfaceTest, P2pSetPowerSaveTest, TestSize.Level1)
141 {
142 int enable = 0;
143 EXPECT_TRUE(P2pSetPowerSave(NULL, enable) == WIFI_HAL_FAILED);
144 EXPECT_TRUE(P2pSetPowerSave(P2pTestInterface, enable) == WIFI_HAL_SUCCESS);
145 }
146
147 HWTEST_F(WifiHalP2pInterfaceTest, P2pSetWfdEnableTest, TestSize.Level1)
148 {
149 EXPECT_TRUE(P2pSetWfdEnable(0) == WIFI_HAL_SUCCESS);
150 }
151
152 HWTEST_F(WifiHalP2pInterfaceTest, P2pSetWfdDeviceConfigTest, TestSize.Level1)
153 {
154 EXPECT_TRUE(P2pSetWfdDeviceConfig(nullptr) == WIFI_HAL_FAILED);
155 EXPECT_TRUE(P2pSetWfdDeviceConfig("input what?") == WIFI_HAL_SUCCESS);
156 }
157
158 HWTEST_F(WifiHalP2pInterfaceTest, P2pStartFindTest, TestSize.Level1)
159 {
160 EXPECT_TRUE(P2pStartFind(0) == WIFI_HAL_SUCCESS);
161 }
162
163 HWTEST_F(WifiHalP2pInterfaceTest, P2pStopP2pFindTest, TestSize.Level1)
164 {
165 EXPECT_TRUE(P2pStopFind() == WIFI_HAL_SUCCESS);
166 }
167
168 HWTEST_F(WifiHalP2pInterfaceTest, P2pSetExtListenTest, TestSize.Level1)
169 {
170 EXPECT_TRUE(P2pSetExtListen(1, 500, 500) == WIFI_HAL_SUCCESS);
171 }
172
173 HWTEST_F(WifiHalP2pInterfaceTest, P2pSetListenChannelTest, TestSize.Level1)
174 {
175 EXPECT_TRUE(P2pSetListenChannel(1, 500) == WIFI_HAL_SUCCESS);
176 }
177
178 HWTEST_F(WifiHalP2pInterfaceTest, P2pConnectTest, TestSize.Level1)
179 {
180 EXPECT_TRUE(P2pConnect(NULL) == WIFI_HAL_FAILED);
181 P2pConnectInfo info;
182 ASSERT_TRUE(memset_s(&info, sizeof(info), 0, sizeof(info)) == EOK);
183 EXPECT_TRUE(P2pConnect(&info) == WIFI_HAL_SUCCESS);
184 }
185
186 HWTEST_F(WifiHalP2pInterfaceTest, P2pCancelConnectTest, TestSize.Level1)
187 {
188 EXPECT_TRUE(P2pCancelConnect() == WIFI_HAL_SUCCESS);
189 }
190
191 HWTEST_F(WifiHalP2pInterfaceTest, P2pProvisionDiscoveryTest, TestSize.Level1)
192 {
193 EXPECT_TRUE(P2pProvisionDiscovery(nullptr, 0) == WIFI_HAL_FAILED);
194 EXPECT_TRUE(P2pProvisionDiscovery("00:00:00:00:00:00", (int)HAL_WPS_METHOD_PBC) == WIFI_HAL_SUCCESS);
195 }
196
197 HWTEST_F(WifiHalP2pInterfaceTest, P2pAddGroupTest, TestSize.Level1)
198 {
199 EXPECT_TRUE(P2pAddGroup(1, -1, 0) == WIFI_HAL_SUCCESS);
200 }
201
202 HWTEST_F(WifiHalP2pInterfaceTest, P2pRemoveGroupTest, TestSize.Level1)
203 {
204 EXPECT_TRUE(P2pRemoveGroup(nullptr) == WIFI_HAL_FAILED);
205 const char *name = "p2p-wlan0-0";
206 EXPECT_TRUE(P2pRemoveGroup(name) == WIFI_HAL_SUCCESS);
207 }
208
209 HWTEST_F(WifiHalP2pInterfaceTest, P2pInviteTest, TestSize.Level1)
210 {
211 EXPECT_TRUE(P2pInvite(0, nullptr, nullptr, nullptr) == WIFI_HAL_FAILED);
212 EXPECT_TRUE(P2pInvite(1, "00:00:00:00:00:00", "00:00:00:00:00:00", "p2p-dev-wlan0") == WIFI_HAL_SUCCESS);
213 }
214
215 HWTEST_F(WifiHalP2pInterfaceTest, P2pReinvokeTest, TestSize.Level1)
216 {
217 EXPECT_TRUE(P2pReinvoke(0, nullptr) == WIFI_HAL_FAILED);
218 EXPECT_TRUE(P2pReinvoke(0, "00:00:00:00:00:00") == WIFI_HAL_SUCCESS);
219 }
220
221 HWTEST_F(WifiHalP2pInterfaceTest, P2pGetGroupCapabilityTest, TestSize.Level1)
222 {
223 EXPECT_TRUE(P2pGetGroupCapability(nullptr, nullptr) == WIFI_HAL_FAILED);
224 int capability = 0;
225 EXPECT_TRUE(P2pGetGroupCapability("00:00:00:00:00:00", &capability) == WIFI_HAL_SUCCESS);
226 }
227
228 HWTEST_F(WifiHalP2pInterfaceTest, P2pAddServiceTest, TestSize.Level1)
229 {
230 EXPECT_TRUE(P2pAddService(nullptr) == WIFI_HAL_FAILED);
231 P2pServiceInfo info;
232 ASSERT_TRUE(memset_s(&info, sizeof(info), 0, sizeof(info)) == EOK);
233 EXPECT_TRUE(P2pAddService(&info) == WIFI_HAL_INVALID_PARAM);
234 info.mode = 0;
235 StrSafeCopy(info.name, sizeof(info.name), "test_name");
236 EXPECT_TRUE(P2pAddService(&info) == WIFI_HAL_SUCCESS);
237 info.mode = 1;
238 StrSafeCopy(info.query, sizeof(info.query), "query");
239 StrSafeCopy(info.resp, sizeof(info.resp), "response");
240 EXPECT_TRUE(P2pAddService(&info) == WIFI_HAL_SUCCESS);
241 }
242
243 HWTEST_F(WifiHalP2pInterfaceTest, P2pRemoveServiceTest, TestSize.Level1)
244 {
245 EXPECT_TRUE(P2pRemoveService(nullptr) == WIFI_HAL_FAILED);
246 P2pServiceInfo info;
247 ASSERT_TRUE(memset_s(&info, sizeof(info), 0, sizeof(info)) == EOK);
248 EXPECT_TRUE(P2pRemoveService(&info) == WIFI_HAL_INVALID_PARAM);
249 info.mode = 0;
250 StrSafeCopy(info.name, sizeof(info.name), "test_name");
251 EXPECT_TRUE(P2pRemoveService(&info) == WIFI_HAL_SUCCESS);
252 info.mode = 1;
253 StrSafeCopy(info.query, sizeof(info.query), "query");
254 StrSafeCopy(info.resp, sizeof(info.resp), "response");
255 EXPECT_TRUE(P2pRemoveService(&info) == WIFI_HAL_SUCCESS);
256 }
257
258 HWTEST_F(WifiHalP2pInterfaceTest, P2pReqServiceDiscoveryTest, TestSize.Level1)
259 {
260 EXPECT_TRUE(P2pReqServiceDiscovery(nullptr, nullptr, nullptr, 0) == WIFI_HAL_FAILED);
261 char disc[1024] = {0};
262 EXPECT_TRUE(P2pReqServiceDiscovery("00:00:00:00:00:00", "HELLO,MESSAGE", disc, 1024) == WIFI_HAL_SUCCESS);
263 }
264
265 HWTEST_F(WifiHalP2pInterfaceTest, P2pCancelServiceDiscoveryTest, TestSize.Level1)
266 {
267 EXPECT_TRUE(P2pCancelServiceDiscovery(nullptr) == WIFI_HAL_FAILED);
268 EXPECT_TRUE(P2pCancelServiceDiscovery("string id") == WIFI_HAL_SUCCESS);
269 }
270
271 HWTEST_F(WifiHalP2pInterfaceTest, P2pSetMiracastTypeTest, TestSize.Level1)
272 {
273 EXPECT_TRUE(P2pSetMiracastType(0) == WIFI_HAL_NOT_SUPPORT);
274 }
275
276 HWTEST_F(WifiHalP2pInterfaceTest, P2pRespServerDiscoveryTest, TestSize.Level1)
277 {
278 EXPECT_TRUE(P2pRespServerDiscovery(nullptr) == WIFI_HAL_FAILED);
279 P2pServDiscReqInfo info;
280 ASSERT_TRUE(memset_s(&info, sizeof(info), 0, sizeof(info)) == EOK);
281 info.tlvs = (char *)calloc(32, sizeof(char));
282 EXPECT_TRUE(P2pRespServerDiscovery(&info) == WIFI_HAL_SUCCESS);
283 free(info.tlvs);
284 }
285
286 HWTEST_F(WifiHalP2pInterfaceTest, P2pSetServDiscExternalTest, TestSize.Level1)
287 {
288 EXPECT_TRUE(P2pSetServDiscExternal(0) == WIFI_HAL_SUCCESS);
289 }
290
291 HWTEST_F(WifiHalP2pInterfaceTest, P2pSetPersistentReconnectTest, TestSize.Level1)
292 {
293 EXPECT_TRUE(P2pSetPersistentReconnect(0) == WIFI_HAL_SUCCESS);
294 }
295
296 HWTEST_F(WifiHalP2pInterfaceTest, P2pStopTest, TestSize.Level1)
297 {
298 EXPECT_TRUE(P2pStop() == WIFI_HAL_SUCCESS);
299 }
300
301 HWTEST_F(WifiHalP2pInterfaceTest, P2pForceStopTest, TestSize.Level1)
302 {
303 EXPECT_TRUE(P2pForceStop() == WIFI_HAL_SUCCESS);
304 }
305
306 HWTEST_F(WifiHalP2pInterfaceTest, P2pSetWpsSecondaryDeviceTypeTest, TestSize.Level1)
307 {
308 char type[] = "P2pSetWpsDeviceType";
309 EXPECT_NE(P2pSetWpsSecondaryDeviceType(NULL),0);
310 EXPECT_NE(P2pSetWpsSecondaryDeviceType(type),0);
311 }
312
313 HWTEST_F(WifiHalP2pInterfaceTest, P2pGetPeerTest, TestSize.Level1)
314 {
315 char type[] = "P2pGetPeer";
316 P2pDeviceInfo peerInfo;
317 EXPECT_TRUE(P2pGetPeer(NULL, NULL) == WIFI_HAL_FAILED);
318 EXPECT_TRUE(P2pGetPeer(type, NULL) == WIFI_HAL_FAILED);
319 EXPECT_TRUE(P2pGetPeer(type, &peerInfo) == WIFI_HAL_FAILED);
320 }
321
322 HWTEST_F(WifiHalP2pInterfaceTest, P2pGetFrequenciesTest, TestSize.Level1)
323 {
324 int peerInfo = 1;
325 int frequencies = 0;
326 EXPECT_TRUE(P2pGetFrequencies(0, NULL, NULL) == WIFI_HAL_FAILED);
327 EXPECT_TRUE(P2pGetFrequencies(0, &frequencies, NULL) == WIFI_HAL_FAILED);
328 EXPECT_TRUE(P2pGetFrequencies(0, &frequencies, &peerInfo) == WIFI_HAL_NOT_SUPPORT);
329 }
330
331 HWTEST_F(WifiHalP2pInterfaceTest, P2pSetGroupConfigTest, TestSize.Level1)
332 {
333 P2pGroupConfig pConfig;
334 int size = 1;
335 EXPECT_TRUE(P2pSetGroupConfig(0, NULL, 0) == WIFI_HAL_FAILED);
336 EXPECT_TRUE(P2pSetGroupConfig(0, &pConfig, 0) == WIFI_HAL_FAILED);
337 EXPECT_TRUE(P2pSetGroupConfig(1, &pConfig, size) == WIFI_HAL_FAILED);
338 }
339
340 HWTEST_F(WifiHalP2pInterfaceTest, P2pGetGroupConfigTest, TestSize.Level1)
341 {
342 P2pGroupConfig pConfig;
343 int size = 1;
344 EXPECT_TRUE(P2pGetGroupConfig(0, NULL, 0) == WIFI_HAL_FAILED);
345 EXPECT_TRUE(P2pGetGroupConfig(0, &pConfig, 0) == WIFI_HAL_FAILED);
346 EXPECT_TRUE(P2pGetGroupConfig(1, &pConfig, size) == WIFI_HAL_FAILED);
347 }
348
349 HWTEST_F(WifiHalP2pInterfaceTest, P2pHid2dConnectTest, TestSize.Level1)
350 {
351 Hid2dConnectInfo info;
352 EXPECT_TRUE(P2pHid2dConnect(NULL) == WIFI_HAL_FAILED);
353 EXPECT_TRUE(P2pHid2dConnect(&info) == WIFI_HAL_FAILED);
354 }
355 } // namespace Wifi
356 } // namespace OHOS