1 /*
2 * Copyright (c) 2022-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
16 #include <gtest/gtest.h>
17 #include <securec.h>
18
19 #include "lnn_net_ledger_mock.h"
20 #include "lnn_p2p_info.h"
21 #include "lnn_p2p_info.c"
22 #include "lnn_service_mock.h"
23 #include "lnn_sync_info_mock.h"
24
25 #define JSON_KEY_P2P_ROLE "P2P_ROLE"
26 #define JSON_KEY_P2P_MAC "P2P_MAC"
27 #define JSON_KEY_GO_MAC "GO_MAC"
28 #define JSON_KEY_WIFIDIRECT_ADDR "WIFIDIRECT_ADDR"
29 #define OH_OS_TYPE 10
30 #define HO_OS_TYPE 11
31
32 namespace OHOS {
33 using namespace testing::ext;
34 using namespace testing;
35
36 constexpr char NETWORKID[NETWORK_ID_BUF_LEN] = "345678BNHFCF";
37 constexpr int32_t ERR_MSG_LEN = 0;
38 constexpr int32_t OK_MSG_LEN = 13;
39 constexpr uint8_t MSG[] = "123456BNHFCF";
40 constexpr int32_t PARSE_P2P_INFO_MSG_LEN = 256;
41
42 class LNNP2pInfoTest : public testing::Test {
43 public:
44 static void SetUpTestCase();
45 static void TearDownTestCase();
46 void SetUp();
47 void TearDown();
48 };
49
SetUpTestCase()50 void LNNP2pInfoTest::SetUpTestCase()
51 {
52 }
53
TearDownTestCase()54 void LNNP2pInfoTest::TearDownTestCase()
55 {
56 }
57
SetUp()58 void LNNP2pInfoTest::SetUp()
59 {
60 }
61
TearDown()62 void LNNP2pInfoTest::TearDown()
63 {
64 }
65
66 /*
67 * @tc.name: LNN_GET_P2P_INFO_MSG_TEST_001
68 * @tc.desc: test LnnGetP2pInfoMsg
69 * @tc.type: FUNC
70 * @tc.require:
71 */
72 HWTEST_F(LNNP2pInfoTest, LNN_GET_P2P_INFO_MSG_TEST_001, TestSize.Level1)
73 {
74 P2pInfo info = {
75 .p2pRole = 1234,
76 .wifiCfg = "wifi_cgf",
77 .chanList5g = "chanList5g",
78 .staFrequency = 500,
79 .p2pMac = "p2pMac",
80 .goMac = "goMac",
81 };
82 char *ret = LnnGetP2pInfoMsg(&info);
83 EXPECT_NE(ret, nullptr);
84 }
85
86 /*
87 * @tc.name: LNN_GET_WIFI_DIRECT_ADDR_MSG_TEST_001
88 * @tc.desc: test LnnGetWifiDirectAddrMsg
89 * @tc.type: FUNC
90 * @tc.require:
91 */
92 HWTEST_F(LNNP2pInfoTest, LNN_GET_WIFI_DIRECT_ADDR_MSG_TEST_001, TestSize.Level1)
93 {
94 NodeInfo info = { .wifiDirectAddr = "wifiDirectAddr", };
95 char *ret = LnnGetWifiDirectAddrMsg(&info);
96 EXPECT_NE(ret, nullptr);
97 }
98
99 /*
100 * @tc.name: P2P_INFO_MOCK_TEST_001
101 * @tc.desc: test LnnInitLocalP2pInfo
102 * @tc.type: FUNC
103 * @tc.require:
104 */
105 HWTEST_F(LNNP2pInfoTest, P2P_INFO_MOCK_TEST_001, TestSize.Level1)
106 {
107 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
108 ON_CALL(netLedgerMock, LnnSetP2pRole).WillByDefault(Return(SOFTBUS_OK));
109 ON_CALL(netLedgerMock, LnnSetP2pMac).WillByDefault(Return(SOFTBUS_OK));
110 ON_CALL(netLedgerMock, LnnSetP2pGoMac).WillByDefault(Return(SOFTBUS_OK));
111 ON_CALL(netLedgerMock, LnnSetWifiDirectAddr).WillByDefault(Return(SOFTBUS_OK));
112 NodeInfo info;
113 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
114 int32_t ret = LnnInitLocalP2pInfo(&info);
115 EXPECT_EQ(ret, SOFTBUS_OK);
116
117 ret = LnnInitLocalP2pInfo(nullptr);
118 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
119
120 EXPECT_CALL(netLedgerMock, LnnSetP2pRole(_, _)).WillRepeatedly(Return(SOFTBUS_ERR));
121 ret = LnnInitLocalP2pInfo(&info);
122 EXPECT_NE(ret, SOFTBUS_OK);
123
124 EXPECT_CALL(netLedgerMock, LnnSetP2pMac(_, _)).WillRepeatedly(Return(SOFTBUS_ERR));
125 ret = LnnInitLocalP2pInfo(&info);
126 EXPECT_NE(ret, SOFTBUS_OK);
127
128 EXPECT_CALL(netLedgerMock, LnnSetP2pGoMac(_, _)).WillRepeatedly(Return(SOFTBUS_ERR));
129 ret = LnnInitLocalP2pInfo(&info);
130 EXPECT_NE(ret, SOFTBUS_OK);
131
132 EXPECT_CALL(netLedgerMock, LnnSetWifiDirectAddr(_, _)).WillRepeatedly(Return(SOFTBUS_ERR));
133 ret = LnnInitLocalP2pInfo(&info);
134 EXPECT_NE(ret, SOFTBUS_OK);
135 }
136
137 /*
138 * @tc.name: LNN_PARSE_WIFI_DIRECT_ADDR_MSG_TEST_001
139 * @tc.desc: test LnnParseWifiDirectAddrMsg
140 * @tc.type: FUNC
141 * @tc.require:
142 */
143 HWTEST_F(LNNP2pInfoTest, LNN_PARSE_WIFI_DIRECT_ADDR_MSG_TEST_001, TestSize.Level1)
144 {
145 char wifiDirectAddr[MAC_LEN] = { 0 };
146 char msg[PARSE_P2P_INFO_MSG_LEN] = "{\"WIFIDIRECT_ADDR\":\"192.168.12.12\"}";
147 int32_t ret = LnnParseWifiDirectAddrMsg(msg, wifiDirectAddr, strlen(msg));
148 EXPECT_EQ(ret, SOFTBUS_OK);
149 ret = LnnParseWifiDirectAddrMsg(nullptr, wifiDirectAddr, 0);
150 EXPECT_EQ(ret, SOFTBUS_PARSE_JSON_ERR);
151 char msg1[PARSE_P2P_INFO_MSG_LEN] = "{\"test\":\"192.168.12.12\"}";
152 ret = LnnParseWifiDirectAddrMsg(msg1, wifiDirectAddr, strlen(msg1));
153 EXPECT_EQ(ret, SOFTBUS_ERR);
154 }
155
156 /*
157 * @tc.name: IS_NEED_SYNC_P2P_INFO_TEST_001
158 * @tc.desc: test IsNeedSyncP2pInfo
159 * @tc.type: FUNC
160 * @tc.require:
161 */
162 HWTEST_F(LNNP2pInfoTest, IS_NEED_SYNC_P2P_INFO_TEST_001, TestSize.Level1)
163 {
164 NiceMock<LnnServicetInterfaceMock> lnnServiceMock;
165 EXPECT_CALL(lnnServiceMock, IsFeatureSupport).WillOnce(Return(false));
166 NodeInfo localInfo;
167 (void)memset_s(&localInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
168 NodeBasicInfo info;
169 (void)memset_s(&info, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
170 bool ret = IsNeedSyncP2pInfo(&localInfo, &info);
171 EXPECT_EQ(ret, true);
172 EXPECT_CALL(lnnServiceMock, IsFeatureSupport).WillRepeatedly(Return(true));
173 int32_t osType = HO_OS_TYPE;
174 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
175 EXPECT_CALL(netLedgerMock, LnnGetOsTypeByNetworkId)
176 .WillOnce(DoAll(SetArgPointee<1>(osType), Return(SOFTBUS_ERR)));
177 ret = IsNeedSyncP2pInfo(&localInfo, &info);
178 EXPECT_EQ(ret, true);
179 }
180
181 /*
182 * @tc.name: PROCESS_SYNC_P2P_INFO_TEST_001
183 * @tc.desc: test ProcessSyncP2pInfo
184 * @tc.type: FUNC
185 * @tc.require:
186 */
187 HWTEST_F(LNNP2pInfoTest, PROCESS_SYNC_P2P_INFO_TEST_001, TestSize.Level1)
188 {
189 NodeInfo info = {
190 .p2pInfo.p2pRole = 1234,
191 .p2pInfo.wifiCfg = "wifi_cgf",
192 .p2pInfo.chanList5g = "chanList5g",
193 .p2pInfo.staFrequency = 500,
194 .p2pInfo.p2pMac = "p2pMac",
195 .p2pInfo.goMac = "goMac",
196 .wifiDirectAddr = "wifiDirectAddr",
197 };
198 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
199 EXPECT_CALL(netLedgerMock, LnnGetAllOnlineAndMetaNodeInfo)
200 .WillOnce(Return(SOFTBUS_ERR))
201 .WillOnce(Return(SOFTBUS_ERR));
202 ProcessSyncP2pInfo(nullptr);
203 ProcessSyncWifiDirectAddr(nullptr);
204 int32_t infoNum = 0;
205 EXPECT_CALL(netLedgerMock, LnnGetAllOnlineAndMetaNodeInfo)
206 .WillOnce(DoAll(SetArgPointee<1>(infoNum), Return(SOFTBUS_OK)))
207 .WillOnce(DoAll(SetArgPointee<1>(infoNum), Return(SOFTBUS_OK)));
208 ProcessSyncP2pInfo(nullptr);
209 ProcessSyncWifiDirectAddr(nullptr);
210 EXPECT_CALL(netLedgerMock, LnnGetAllOnlineAndMetaNodeInfo).WillRepeatedly(
211 LnnNetLedgertInterfaceMock::ActionOfLnnGetAllOnline);
212 EXPECT_CALL(netLedgerMock, LnnGetLocalNodeInfo).WillRepeatedly(Return(nullptr));
213 ProcessSyncP2pInfo(nullptr);
214 ProcessSyncWifiDirectAddr(nullptr);
215 EXPECT_CALL(netLedgerMock, LnnGetLocalNodeInfo).WillRepeatedly(Return(&info));
216 EXPECT_CALL(netLedgerMock, LnnIsLSANode).WillRepeatedly(Return(false));
217 EXPECT_CALL(netLedgerMock, LnnGetOsTypeByNetworkId)
218 .WillRepeatedly(DoAll(SetArgPointee<1>(HO_OS_TYPE), Return(SOFTBUS_ERR)));
219 NiceMock<LnnServicetInterfaceMock> lnnServiceMock;
220 EXPECT_CALL(lnnServiceMock, IsFeatureSupport).WillRepeatedly(Return(false));
221 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
222 EXPECT_CALL(lnnSyncInfoMock, LnnSendSyncInfoMsg).WillRepeatedly(Return(SOFTBUS_ERR));
223 ProcessSyncP2pInfo(nullptr);
224 ProcessSyncWifiDirectAddr(nullptr);
225 }
226
227 /*
228 * @tc.name: PROCESS_SYNC_P2P_INFO_TEST_002
229 * @tc.desc: test ProcessSyncP2pInfo
230 * @tc.type: FUNC
231 * @tc.require:
232 */
233 HWTEST_F(LNNP2pInfoTest, PROCESS_SYNC_P2P_INFO_TEST_002, TestSize.Level1)
234 {
235 NodeInfo info = {
236 .p2pInfo.p2pRole = 1234,
237 .p2pInfo.wifiCfg = "wifi_cgf",
238 .p2pInfo.chanList5g = "chanList5g",
239 .p2pInfo.staFrequency = 500,
240 .p2pInfo.p2pMac = "p2pMac",
241 .p2pInfo.goMac = "goMac",
242 .wifiDirectAddr = "wifiDirectAddr",
243 };
244 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
245 EXPECT_CALL(netLedgerMock, LnnGetAllOnlineAndMetaNodeInfo).WillRepeatedly(
246 LnnNetLedgertInterfaceMock::ActionOfLnnGetAllOnline);
247 EXPECT_CALL(netLedgerMock, LnnGetLocalNodeInfo).WillRepeatedly(Return(&info));
248 EXPECT_CALL(netLedgerMock, LnnIsLSANode).WillRepeatedly(Return(true));
249 ProcessSyncP2pInfo(nullptr);
250 ProcessSyncWifiDirectAddr(nullptr);
251 EXPECT_CALL(netLedgerMock, LnnGetOsTypeByNetworkId)
252 .WillRepeatedly(DoAll(SetArgPointee<1>(OH_OS_TYPE), Return(SOFTBUS_OK)));
253 NiceMock<LnnServicetInterfaceMock> lnnServiceMock;
254 EXPECT_CALL(lnnServiceMock, IsFeatureSupport).WillRepeatedly(Return(false));
255 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
256 EXPECT_CALL(lnnSyncInfoMock, LnnSendSyncInfoMsg).WillRepeatedly(Return(SOFTBUS_OK));
257 ProcessSyncP2pInfo(nullptr);
258 ProcessSyncWifiDirectAddr(nullptr);
259 EXPECT_CALL(netLedgerMock, LnnGetOsTypeByNetworkId)
260 .WillRepeatedly(DoAll(SetArgPointee<1>(HO_OS_TYPE), Return(SOFTBUS_OK)));
261 ProcessSyncWifiDirectAddr(nullptr);
262 }
263
264 /*
265 * @tc.name: ON_RECEIVE_WIFI_DIRECT_SYNC_ADDR_TEST_001
266 * @tc.desc: test OnReceiveWifiDirectSyncAddr
267 * @tc.type: FUNC
268 * @tc.require:
269 */
270 HWTEST_F(LNNP2pInfoTest, ON_RECEIVE_WIFI_DIRECT_SYNC_ADDR_TEST_001, TestSize.Level1)
271 {
272 NodeInfo info = { .wifiDirectAddr = "wifiDirectAddr", };
273 char *msg = LnnGetWifiDirectAddrMsg(&info);
274 EXPECT_NE(msg, nullptr);
275 OnReceiveWifiDirectSyncAddr(LNN_INFO_TYPE_OFFLINE, NETWORKID, MSG, ERR_MSG_LEN);
276 OnReceiveWifiDirectSyncAddr(LNN_INFO_TYPE_WIFI_DIRECT, NETWORKID, nullptr, ERR_MSG_LEN);
277 OnReceiveWifiDirectSyncAddr(LNN_INFO_TYPE_WIFI_DIRECT, NETWORKID, MSG, ERR_MSG_LEN);
278 OnReceiveWifiDirectSyncAddr(LNN_INFO_TYPE_WIFI_DIRECT, nullptr, MSG, OK_MSG_LEN);
279 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
280 EXPECT_CALL(netLedgerMock, LnnSetDLWifiDirectAddr)
281 .WillOnce(Return(SOFTBUS_ERR))
282 .WillRepeatedly(Return(SOFTBUS_OK));
283 OnReceiveWifiDirectSyncAddr(LNN_INFO_TYPE_WIFI_DIRECT, NETWORKID,
284 reinterpret_cast<const uint8_t *>(msg), strlen(msg));
285 OnReceiveWifiDirectSyncAddr(LNN_INFO_TYPE_WIFI_DIRECT, NETWORKID,
286 reinterpret_cast<const uint8_t *>(msg), strlen(msg));
287 }
288
289
290 /*
291 * @tc.name: LNN_SYNC_P2P_INFO_TEST_001
292 * @tc.desc: test LnnSyncP2pInfo
293 * @tc.type: FUNC
294 * @tc.require:
295 */
296 HWTEST_F(LNNP2pInfoTest, LNN_SYNC_P2P_INFO_TEST_001, TestSize.Level1)
297 {
298 NiceMock<LnnServicetInterfaceMock> lnnServiceMock;
299 EXPECT_CALL(lnnServiceMock, LnnAsyncCallbackHelper)
300 .WillOnce(Return(SOFTBUS_ERR))
301 .WillRepeatedly(Return(SOFTBUS_OK));
302 int32_t ret = LnnSyncP2pInfo();
303 EXPECT_EQ(ret, SOFTBUS_ERR);
304 ret = LnnSyncP2pInfo();
305 EXPECT_EQ(ret, SOFTBUS_OK);
306 }
307
308 /*
309 * @tc.name: LNN_SYNC_WIFI_DIRECT_ADDR_TEST_001
310 * @tc.desc: test LnnSyncWifiDirectAddr
311 * @tc.type: FUNC
312 * @tc.require:
313 */
314 HWTEST_F(LNNP2pInfoTest, LNN_SYNC_WIFI_DIRECT_ADDR_TEST_001, TestSize.Level1)
315 {
316 NiceMock<LnnServicetInterfaceMock> lnnServiceMock;
317 EXPECT_CALL(lnnServiceMock, LnnAsyncCallbackHelper)
318 .WillOnce(Return(SOFTBUS_ERR))
319 .WillRepeatedly(Return(SOFTBUS_OK));
320 int32_t ret = LnnSyncWifiDirectAddr();
321 EXPECT_EQ(ret, SOFTBUS_ERR);
322 ret = LnnSyncWifiDirectAddr();
323 EXPECT_EQ(ret, SOFTBUS_OK);
324 }
325
326 /*
327 * @tc.name: LNN_PARSE_P2P_INFO_MSG_TEST_001
328 * @tc.desc: test LnnParseP2pInfoMsg
329 * @tc.type: FUNC
330 * @tc.require:
331 */
332 HWTEST_F(LNNP2pInfoTest, LNN_PARSE_P2P_INFO_MSG_TEST_001, TestSize.Level1)
333 {
334 char msg[PARSE_P2P_INFO_MSG_LEN] = "{\"P2P_ROLE\":1234}";
335 P2pInfo info = {};
336 int32_t ret = LnnParseP2pInfoMsg(msg, &info, 0);
337 EXPECT_TRUE(ret == SOFTBUS_PARSE_JSON_ERR);
338
339 (void)strcpy_s(msg, sizeof(msg), "{\"WIFI_CFG\":1234}");
340 ret = LnnParseP2pInfoMsg(msg, &info, strlen(msg) + 1);
341 EXPECT_TRUE(ret == SOFTBUS_ERR);
342
343 (void)strcpy_s(msg, sizeof(msg), "{\"P2P_ROLE\":1234}");
344 ret = LnnParseP2pInfoMsg(msg, &info, strlen(msg) + 1);
345 EXPECT_TRUE(ret == SOFTBUS_ERR);
346
347 (void)strcpy_s(msg, sizeof(msg), "{\"P2P_ROLE\":1234, \"WIFI_CFG\":\"wifi_cgf\"}");
348 ret = LnnParseP2pInfoMsg(msg, &info, strlen(msg) + 1);
349 EXPECT_TRUE(ret == SOFTBUS_ERR);
350
351 (void)strcpy_s(msg, sizeof(msg), "{\"P2P_ROLE\":1234, \"WIFI_CFG\":\"wifi_cgf\", "\
352 "\"CHAN_LIST_5G\":\"CHAN_LIST_5G\"}");
353 ret = LnnParseP2pInfoMsg(msg, &info, strlen(msg) + 1);
354 EXPECT_TRUE(ret == SOFTBUS_ERR);
355
356 (void)strcpy_s(msg, sizeof(msg), "{\"P2P_ROLE\":1234, \"WIFI_CFG\":\"wifi_cgf\", "\
357 "\"CHAN_LIST_5G\":\"CHAN_LIST_5G\", \"STA_FREQUENCY\":2008}");
358 ret = LnnParseP2pInfoMsg(msg, &info, strlen(msg) + 1);
359 EXPECT_TRUE(ret == SOFTBUS_ERR);
360
361 (void)strcpy_s(msg, sizeof(msg), "{\"P2P_ROLE\":1234, \"WIFI_CFG\":\"wifi_cgf\", "\
362 "\"CHAN_LIST_5G\":\"CHAN_LIST_5G\", \"STA_FREQUENCY\":2008, \"P2P_MAC\":\"P2P_MAC\"}");
363 ret = LnnParseP2pInfoMsg(msg, &info, strlen(msg) + 1);
364 EXPECT_TRUE(ret == SOFTBUS_ERR);
365
366 (void)strcpy_s(msg, sizeof(msg), "{\"P2P_ROLE\":1234, \"WIFI_CFG\":\"wifi_cgf\", "\
367 "\"CHAN_LIST_5G\":\"CHAN_LIST_5G\",\"STA_FREQUENCY\":2008, \"P2P_MAC\":\"P2P_MAC\", \"GO_MAC\":\"GO_MAC\"}");
368 ret = LnnParseP2pInfoMsg(msg, &info, strlen(msg) + 1);
369 EXPECT_TRUE(ret == SOFTBUS_OK);
370 }
371
372 /*
373 * @tc.name: ON_RECEIVE_P2P_SYNC_INFO_MSG_TEST_001
374 * @tc.desc: test OnReceiveP2pSyncInfoMsg
375 * @tc.type: FUNC
376 * @tc.require:
377 */
378 HWTEST_F(LNNP2pInfoTest, ON_RECEIVE_P2P_SYNC_INFO_MSG_TEST_001, TestSize.Level1)
379 {
380 P2pInfo info = {
381 .p2pRole = 1234,
382 .wifiCfg = "wifi_cgf",
383 .chanList5g = "chanList5g",
384 .staFrequency = 500,
385 .p2pMac = "p2pMac",
386 .goMac = "goMac",
387 };
388 char *msg = LnnGetP2pInfoMsg(&info);
389 EXPECT_NE(msg, nullptr);
390 OnReceiveP2pSyncInfoMsg(LNN_INFO_TYPE_OFFLINE, NETWORKID, MSG, ERR_MSG_LEN);
391 OnReceiveP2pSyncInfoMsg(LNN_INFO_TYPE_P2P_INFO, NETWORKID, nullptr, ERR_MSG_LEN);
392 OnReceiveP2pSyncInfoMsg(LNN_INFO_TYPE_P2P_INFO, NETWORKID, MSG, ERR_MSG_LEN);
393 OnReceiveP2pSyncInfoMsg(LNN_INFO_TYPE_P2P_INFO, nullptr, MSG, OK_MSG_LEN);
394 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
395 EXPECT_CALL(netLedgerMock, LnnSetDLP2pInfo)
396 .WillOnce(Return(false))
397 .WillRepeatedly(Return(true));
398 OnReceiveP2pSyncInfoMsg(LNN_INFO_TYPE_P2P_INFO, NETWORKID,
399 reinterpret_cast<const uint8_t *>(msg), strlen(msg));
400 OnReceiveP2pSyncInfoMsg(LNN_INFO_TYPE_P2P_INFO, NETWORKID,
401 reinterpret_cast<const uint8_t *>(msg), strlen(msg));
402 }
403 } // namespace OHOS
404