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