1 /*
2 * Copyright (c) 2024-2025 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
18 #include "bus_center_utils_mock.h"
19 #include "lnn_async_callback_utils.h"
20 #include "lnn_common_utils.h"
21 #include "lnn_compress.h"
22 #include "lnn_map.h"
23 #include "lnn_network_id.c"
24 #include "lnn_network_id.h"
25 #include "lnn_state_machine.h"
26 #include "softbus_adapter_mem.h"
27 #include "softbus_common.h"
28 #include "softbus_def.h"
29 #include "softbus_error_code.h"
30
31 namespace OHOS {
32 using namespace testing::ext;
33 using namespace testing;
34 static Map g_bcUtilsMap;
35 #define NETWORK_ID_BUF_LEN 65
36 #define HDF_MAP_VALUE_MAX_SIZE 4000
37 #define FSM_MSG_TYPE_JOIN_LNN_TIMEOUT 6
38
39 class BusCenterUtilsTest : public testing::Test {
40 public:
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 void SetUp();
44 void TearDown();
45 };
46
SetUpTestCase()47 void BusCenterUtilsTest::SetUpTestCase() {}
48
TearDownTestCase()49 void BusCenterUtilsTest::TearDownTestCase() {}
50
SetUp()51 void BusCenterUtilsTest::SetUp() {}
52
TearDown()53 void BusCenterUtilsTest::TearDown() {}
54
LooperRemoveMessage(const SoftBusLooper * looper,const SoftBusHandler * handler,int32_t what)55 static void LooperRemoveMessage(const SoftBusLooper *looper, const SoftBusHandler *handler, int32_t what)
56 {
57 (void)looper;
58 (void)handler;
59 (void)what;
60 }
61
LoopRemoveMessageCustom(const SoftBusLooper * looper,const SoftBusHandler * handler,int (* customFunc)(const SoftBusMessage *,void *),void * args)62 static void LoopRemoveMessageCustom(const SoftBusLooper *looper, const SoftBusHandler *handler,
63 int (*customFunc)(const SoftBusMessage*, void*), void *args)
64 {
65 (void)looper;
66 (void)handler;
67 (void)customFunc;
68 (void)args;
69 }
70
LooperPostMessageDelay(const SoftBusLooper * looper,SoftBusMessage * msg,uint64_t delayMillis)71 static void LooperPostMessageDelay(const SoftBusLooper *looper, SoftBusMessage *msg, uint64_t delayMillis)
72 {
73 (void)looper;
74 (void)msg;
75 (void)delayMillis;
76 }
77
78 static SoftBusHandler g_buscenterUtilsHandler = {
79 .name = (char *)"g_buscenterUtilsHandler"
80 };
81
82 /*
83 * @tc.name: GET_UUID_FROM_FILE_TEST_001
84 * @tc.desc: get uuid from file test
85 * @tc.type: FUNC
86 * @tc.require:
87 */
88 HWTEST_F(BusCenterUtilsTest, GET_UUID_FROM_FILE_TEST_001, TestSize.Level1)
89 {
90 NiceMock<BusCenterUtilsInterfaceMock> bcUtilsMock;
91 EXPECT_CALL(bcUtilsMock, LnnGetFullStoragePath)
92 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
93 .WillRepeatedly(Return(SOFTBUS_OK));
94 char id[] = "11u22u33i44d55";
95 int32_t ret = GetUuidFromFile(id, UUID_BUF_LEN, false);
96 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
97
98 EXPECT_CALL(bcUtilsMock, SoftBusReadFullFile).WillRepeatedly(Return(SOFTBUS_FILE_ERR));
99 EXPECT_CALL(bcUtilsMock, GenerateRandomStr)
100 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
101 .WillRepeatedly(Return(SOFTBUS_OK));
102 ret = GetUuidFromFile(id, UUID_BUF_LEN, false);
103 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
104
105 EXPECT_CALL(bcUtilsMock, SoftBusWriteFile)
106 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
107 .WillRepeatedly(Return(SOFTBUS_OK));
108 ret = GetUuidFromFile(id, UUID_BUF_LEN, false);
109 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
110
111 ret = GetUuidFromFile(id, UUID_BUF_LEN, false);
112 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_UUID_FROM_FILE_FAILED);
113
114 char id1[] = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00";
115 ret = GetUuidFromFile(id1, UUID_BUF_LEN, false);
116 EXPECT_EQ(ret, SOFTBUS_OK);
117 }
118
119 /*
120 * @tc.name: LNN_GEN_LOCAL_NETWORKID_TEST_001
121 * @tc.desc: lnn generate local networkid test
122 * @tc.type: FUNC
123 * @tc.require:
124 */
125 HWTEST_F(BusCenterUtilsTest, LNN_GEN_LOCAL_NETWORKID_TEST_001, TestSize.Level1)
126 {
127 NiceMock<BusCenterUtilsInterfaceMock> bcUtilsMock;
128 int32_t ret = LnnGenLocalNetworkId(nullptr, NETWORK_ID_BUF_LEN);
129 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
130
131 char networkId[NETWORK_ID_BUF_LEN] = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF0";
132 ret = LnnGenLocalNetworkId(networkId, NETWORK_ID_BUF_LEN - 1);
133 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
134
135 EXPECT_CALL(bcUtilsMock, GenerateRandomStr)
136 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
137 .WillRepeatedly(Return(SOFTBUS_OK));
138 ret = LnnGenLocalNetworkId(networkId, NETWORK_ID_BUF_LEN);
139 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
140
141 ret = LnnGenLocalNetworkId(networkId, NETWORK_ID_BUF_LEN);
142 EXPECT_EQ(ret, SOFTBUS_OK);
143 }
144
145 /*
146 * @tc.name: LNN_GEN_LOCAL_UUID_TEST_001
147 * @tc.desc: lnn generate local uuid test
148 * @tc.type: FUNC
149 * @tc.require:
150 */
151 HWTEST_F(BusCenterUtilsTest, LNN_GEN_LOCAL_UUID_TEST_001, TestSize.Level1)
152 {
153 NiceMock<BusCenterUtilsInterfaceMock> bcUtilsMock;
154 int32_t ret = LnnGenLocalUuid(nullptr, UUID_BUF_LEN, false);
155 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
156
157 char uuid[] = "11u22u33i44d55";
158 ret = LnnGenLocalUuid(uuid, UUID_BUF_LEN - 1, false);
159 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
160
161 EXPECT_CALL(bcUtilsMock, LnnGetFullStoragePath).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
162 ret = LnnGenLocalUuid(uuid, UUID_BUF_LEN, false);
163 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_UUID_FROM_FILE_FAILED);
164 }
165
166 /*
167 * @tc.name: GET_IRK_FROM_FILE_TEST_001
168 * @tc.desc: get irk from file test
169 * @tc.type: FUNC
170 * @tc.require:
171 */
172 HWTEST_F(BusCenterUtilsTest, GET_IRK_FROM_FILE_TEST_001, TestSize.Level1)
173 {
174 NiceMock<BusCenterUtilsInterfaceMock> bcUtilsMock;
175 unsigned char irk[] = "test_irk_123";
176 EXPECT_CALL(bcUtilsMock, LnnGetFullStoragePath)
177 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
178 .WillRepeatedly(Return(SOFTBUS_OK));
179 int32_t ret = GetIrkFromFile(irk, LFINDER_IRK_LEN, false);
180 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
181
182 EXPECT_CALL(bcUtilsMock, SoftBusReadFullFile).WillRepeatedly(Return(SOFTBUS_FILE_ERR));
183 EXPECT_CALL(bcUtilsMock, SoftBusGenerateRandomArray)
184 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
185 .WillRepeatedly(Return(SOFTBUS_OK));
186 ret = GetIrkFromFile(irk, LFINDER_IRK_LEN, false);
187 EXPECT_NE(ret, SOFTBUS_OK);
188
189 EXPECT_CALL(bcUtilsMock, SoftBusWriteFile)
190 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
191 .WillRepeatedly(Return(SOFTBUS_OK));
192 ret = GetIrkFromFile(irk, LFINDER_IRK_LEN, false);
193 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
194
195 ret = GetIrkFromFile(irk, LFINDER_IRK_LEN, false);
196 EXPECT_EQ(ret, SOFTBUS_OK);
197 }
198
199 /*
200 * @tc.name: LNN_GEN_LOCAL_IRK_TEST_001
201 * @tc.desc: lnn generate local irk test
202 * @tc.type: FUNC
203 * @tc.require:
204 */
205 HWTEST_F(BusCenterUtilsTest, LNN_GEN_LOCAL_IRK_TEST_001, TestSize.Level1)
206 {
207 NiceMock<BusCenterUtilsInterfaceMock> bcUtilsMock;
208 unsigned char irk[] = "test_irk_123";
209 int32_t ret = LnnGenLocalIrk(nullptr, LFINDER_IRK_LEN, false);
210 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
211
212 ret = LnnGenLocalIrk(irk, LFINDER_IRK_LEN - 1, false);
213 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
214
215 EXPECT_CALL(bcUtilsMock, LnnGetFullStoragePath)
216 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
217 .WillRepeatedly(Return(SOFTBUS_OK));
218 ret = LnnGenLocalIrk(irk, LFINDER_IRK_LEN, false);
219 EXPECT_EQ(ret, SOFTBUS_GET_IRK_FAIL);
220 }
221
222 /*
223 * @tc.name: LNN_ENCRYPT_AES_GCM_TEST_001
224 * @tc.desc: lnn encrypt aes gcm test
225 * @tc.type: FUNC
226 * @tc.require:
227 */
228 HWTEST_F(BusCenterUtilsTest, LNN_ENCRYPT_AES_GCM_TEST_001, TestSize.Level1)
229 {
230 NiceMock<BusCenterUtilsInterfaceMock> bcUtilsMock;
231 int32_t keyIndex = 0;
232 int32_t ret = LnnEncryptAesGcm(nullptr, keyIndex, nullptr, nullptr);
233 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
234
235 AesGcmInputParam in;
236 (void)memset_s(&in, sizeof(AesGcmInputParam), 0, sizeof(AesGcmInputParam));
237 ret = LnnEncryptAesGcm(&in, keyIndex, nullptr, nullptr);
238 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
239
240 uint8_t *out = nullptr;
241 ret = LnnEncryptAesGcm(&in, keyIndex, &out, nullptr);
242 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
243
244 uint32_t outLen = 0;
245 in.dataLen = UINT32_MAX - OVERHEAD_LEN;
246 ret = LnnEncryptAesGcm(&in, keyIndex, &out, &outLen);
247 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
248
249 in.data = (uint8_t *)"true";
250 in.dataLen = strlen("true");
251 in.key = (uint8_t *)"www.test.com";
252 in.keyLen = SESSION_KEY_LENGTH;
253
254 EXPECT_CALL(bcUtilsMock, SoftBusGenerateRandomArray)
255 .WillOnce(Return(SOFTBUS_ENCRYPT_ERR))
256 .WillRepeatedly(Return(SOFTBUS_OK));
257 ret = LnnEncryptAesGcm(&in, keyIndex, &out, &outLen);
258 EXPECT_EQ(ret, SOFTBUS_ENCRYPT_ERR);
259 SoftBusFree(out);
260
261 ret = LnnEncryptAesGcm(&in, keyIndex, &out, &outLen);
262 EXPECT_EQ(ret, SOFTBUS_OK);
263 in.key = nullptr;
264 SoftBusFree(out);
265 }
266
267 /*
268 * @tc.name: LNN_DECRYPT_AES_GCM_TEST_001
269 * @tc.desc: lnn decrypt aes gcm test
270 * @tc.type: FUNC
271 * @tc.require:
272 */
273 HWTEST_F(BusCenterUtilsTest, LNN_DECRYPT_AES_GCM_TEST_001, TestSize.Level1)
274 {
275 NiceMock<BusCenterUtilsInterfaceMock> bcUtilsMock;
276 int32_t ret = LnnDecryptAesGcm(nullptr, nullptr, nullptr);
277 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
278
279 AesGcmInputParam in;
280 (void)memset_s(&in, sizeof(AesGcmInputParam), 0, sizeof(AesGcmInputParam));
281 ret = LnnDecryptAesGcm(&in, nullptr, nullptr);
282 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
283
284 uint8_t *out = nullptr;
285 ret = LnnDecryptAesGcm(&in, &out, nullptr);
286 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
287
288 uint32_t outLen = 0;
289 in.dataLen = OVERHEAD_LEN;
290 ret = LnnDecryptAesGcm(&in, &out, &outLen);
291 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
292
293 in.data = (uint8_t *)"hw.test.data.true/false.com.s.s";
294 in.dataLen = strlen("hw.test.data.true/false.com.s.s");
295 in.key = (uint8_t *)"www.test.com";
296 in.keyLen = SESSION_KEY_LENGTH;
297 ret = LnnDecryptAesGcm(&in, &out, &outLen);
298 EXPECT_EQ(ret, SOFTBUS_OK);
299 in.key = nullptr;
300 SoftBusFree(out);
301 }
302
303 /*
304 * @tc.name: LNN_MAP_SET_TEST_001
305 * @tc.desc: lnn map set test
306 * @tc.type: FUNC
307 * @tc.require:
308 */
309 HWTEST_F(BusCenterUtilsTest, LNN_MAP_SET_TEST_001, TestSize.Level1)
310 {
311 Map *cMap = (Map *)SoftBusCalloc(sizeof(Map));
312 ASSERT_NE(cMap, nullptr);
313 cMap->nodes = (MapNode **)SoftBusCalloc(sizeof(MapNode *));
314 if (cMap->nodes != nullptr) {
315 cMap->bucketSize = 0;
316 cMap->nodeSize = 1;
317 const char *key = "123412341234abcdef";
318 NodeInfo nodeInfo;
319 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
320 uint32_t valueSize = HDF_MAP_VALUE_MAX_SIZE + 1;
321 int32_t ret = LnnMapSet(cMap, key, &nodeInfo, valueSize);
322 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
323
324 valueSize = HDF_MAP_VALUE_MAX_SIZE;
325 ret = LnnMapSet(cMap, key, &nodeInfo, valueSize);
326 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
327
328 cMap->bucketSize = 1;
329 ret = LnnMapSet(cMap, key, &nodeInfo, valueSize);
330 EXPECT_EQ(ret, SOFTBUS_OK);
331
332 EXPECT_EQ(LnnMapErase(cMap, key), SOFTBUS_OK);
333 EXPECT_NO_FATAL_FAILURE(LnnMapDelete(cMap));
334 }
335 SoftBusFree(cMap);
336 }
337
338 /*
339 * @tc.name: LNN_MAP_GET_TEST_001
340 * @tc.desc: lnn map get test
341 * @tc.type: FUNC
342 * @tc.require:
343 */
344 HWTEST_F(BusCenterUtilsTest, LNN_MAP_GET_TEST_001, TestSize.Level1)
345 {
346 void *ret = LnnMapGet(nullptr, nullptr);
347 EXPECT_EQ(ret, nullptr);
348
349 Map *cMap = (Map *)SoftBusCalloc(sizeof(Map));
350 ASSERT_NE(cMap, nullptr);
351 LnnMapInit(cMap);
352 ret = LnnMapGet(cMap, nullptr);
353 EXPECT_EQ(ret, nullptr);
354
355 const char *key = "123412341234abcdef";
356 ret = LnnMapGet(cMap, key);
357 EXPECT_EQ(ret, nullptr);
358
359 cMap->nodeSize = 1;
360 ret = LnnMapGet(cMap, key);
361 EXPECT_EQ(ret, nullptr);
362
363 NodeInfo nodeInfo;
364 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
365 EXPECT_EQ(LnnMapSet(&g_bcUtilsMap, key, &nodeInfo, HDF_MAP_VALUE_MAX_SIZE), SOFTBUS_OK);
366 cMap->bucketSize = 0;
367 ret = LnnMapGet(cMap, key);
368 EXPECT_EQ(ret, nullptr);
369
370 cMap->bucketSize = 1;
371 ret = LnnMapGet(cMap, key);
372 EXPECT_EQ(ret, nullptr);
373
374 EXPECT_NO_FATAL_FAILURE(LnnMapErase(cMap, key));
375 EXPECT_NO_FATAL_FAILURE(LnnMapDelete(cMap));
376 SoftBusFree(cMap);
377 }
378
379 /*
380 * @tc.name: LNN_MAP_ERASE_TEST_001
381 * @tc.desc: lnn map erase test
382 * @tc.type: FUNC
383 * @tc.require:
384 */
385 HWTEST_F(BusCenterUtilsTest, LNN_MAP_ERASE_TEST_001, TestSize.Level1)
386 {
387 int32_t ret = LnnMapErase(nullptr, nullptr);
388 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
389
390 Map *cMap = (Map *)SoftBusCalloc(sizeof(Map));
391 ASSERT_NE(cMap, nullptr);
392 LnnMapInit(cMap);
393 ret = LnnMapErase(cMap, nullptr);
394 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
395
396 const char *key = "123412341234abcdef";
397 ret = LnnMapErase(cMap, key);
398 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
399
400 cMap->nodeSize = 1;
401 ret = LnnMapErase(cMap, key);
402 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
403
404 NodeInfo nodeInfo;
405 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
406 EXPECT_EQ(LnnMapSet(&g_bcUtilsMap, key, &nodeInfo, HDF_MAP_VALUE_MAX_SIZE), SOFTBUS_OK);
407 cMap->bucketSize = 0;
408 ret = LnnMapErase(cMap, key);
409 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
410
411 cMap->bucketSize = 1;
412 ret = LnnMapErase(cMap, key);
413 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
414
415 EXPECT_NO_FATAL_FAILURE(LnnMapDelete(cMap));
416 SoftBusFree(cMap);
417 }
418
419 /*
420 * @tc.name: LNN_MAP_INIT_TEST_001
421 * @tc.desc: lnn map init test
422 * @tc.type: FUNC
423 * @tc.require:
424 */
425 HWTEST_F(BusCenterUtilsTest, LNN_MAP_INIT_TEST_001, TestSize.Level1)
426 {
427 EXPECT_NO_FATAL_FAILURE(LnnMapInit(nullptr));
428
429 Map *cMap = (Map *)SoftBusCalloc(sizeof(Map));
430 ASSERT_NE(cMap, nullptr);
431 EXPECT_NO_FATAL_FAILURE(LnnMapInit(cMap));
432
433 EXPECT_NO_FATAL_FAILURE(LnnMapDelete(cMap));
434 SoftBusFree(cMap);
435 }
436
437 /*
438 * @tc.name: LNN_MAP_DELETE_TEST_001
439 * @tc.desc: lnn map delete test
440 * @tc.type: FUNC
441 * @tc.require:
442 */
443 HWTEST_F(BusCenterUtilsTest, LNN_MAP_DELETE_TEST_001, TestSize.Level1)
444 {
445 EXPECT_NO_FATAL_FAILURE(LnnMapDelete(nullptr));
446
447 Map *cMap = (Map *)SoftBusCalloc(sizeof(Map));
448 ASSERT_NE(cMap, nullptr);
449 cMap->nodes = nullptr;
450 EXPECT_NO_FATAL_FAILURE(LnnMapDelete(cMap));
451
452 NodeInfo nodeInfo;
453 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
454 const char *key = "123412341234abcdef";
455 EXPECT_EQ(LnnMapSet(&g_bcUtilsMap, key, &nodeInfo, HDF_MAP_VALUE_MAX_SIZE), SOFTBUS_OK);
456 EXPECT_NO_FATAL_FAILURE(LnnMapDelete(cMap));
457 SoftBusFree(cMap);
458 }
459
460 /*
461 * @tc.name: LNN_MAP_INIT_ITERATOR_TEST_001
462 * @tc.desc: lnn map init iterator test
463 * @tc.type: FUNC
464 * @tc.require:
465 */
466 HWTEST_F(BusCenterUtilsTest, LNN_MAP_INIT_ITERATOR_TEST_001, TestSize.Level1)
467 {
468 MapIterator *ret = LnnMapInitIterator(nullptr);
469 EXPECT_EQ(ret, nullptr);
470
471 Map *cMap = (Map *)SoftBusCalloc(sizeof(Map));
472 ASSERT_NE(cMap, nullptr);
473 ret = LnnMapInitIterator(cMap);
474 EXPECT_NE(ret, nullptr);
475
476 EXPECT_NO_FATAL_FAILURE(LnnMapDeinitIterator(ret));
477 SoftBusFree(cMap);
478 }
479
480 /*
481 * @tc.name: LNN_MAP_HAS_NEXT_TEST_001
482 * @tc.desc: lnn map has next test
483 * @tc.type: FUNC
484 * @tc.require:
485 */
486 HWTEST_F(BusCenterUtilsTest, LNN_MAP_HAS_NEXT_TEST_001, TestSize.Level1)
487 {
488 MapIterator *it = (MapIterator *)SoftBusCalloc(sizeof(MapIterator));
489 ASSERT_NE(it, nullptr);
490 it->map = (Map *)SoftBusCalloc(sizeof(Map));
491 if (it->map == nullptr) {
492 SoftBusFree(it);
493 return;
494 }
495 it->map->nodeSize = HDF_MAP_VALUE_MAX_SIZE + 1;
496 it->nodeNum = 1;
497 bool ret = LnnMapHasNext(it);
498 EXPECT_EQ(ret, true);
499
500 it->map->nodeSize = HDF_MAP_VALUE_MAX_SIZE;
501 it->nodeNum = HDF_MAP_VALUE_MAX_SIZE;
502 ret = LnnMapHasNext(it);
503 EXPECT_EQ(ret, false);
504
505 SoftBusFree(it->map);
506 SoftBusFree(it);
507 }
508
509 /*
510 * @tc.name: LNN_MAP_DEINIT_ITERATOR_TEST_001
511 * @tc.desc: lnn map deinit iterator test
512 * @tc.type: FUNC
513 * @tc.require:
514 */
515 HWTEST_F(BusCenterUtilsTest, LNN_MAP_DEINIT_ITERATOR_TEST_001, TestSize.Level1)
516 {
517 EXPECT_NO_FATAL_FAILURE(LnnMapDeinitIterator(nullptr));
518
519 MapIterator *it = (MapIterator *)SoftBusCalloc(sizeof(MapIterator));
520 ASSERT_NE(it, nullptr);
521 EXPECT_NO_FATAL_FAILURE(LnnMapDeinitIterator(it));
522 }
523
524 /*
525 * @tc.name: DATA_COMPRESS_TEST_001
526 * @tc.desc: data compress test
527 * @tc.type: FUNC
528 * @tc.require:
529 */
530 HWTEST_F(BusCenterUtilsTest, DATA_COMPRESS_TEST_001, TestSize.Level1)
531 {
532 int32_t ret = DataCompress(nullptr, 0, nullptr, nullptr);
533 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
534
535 char in[] = "123txt321";
536 ret = DataCompress((uint8_t *)in, 0, nullptr, nullptr);
537 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
538
539 uint32_t inLen = strlen(in);
540 ret = DataCompress((uint8_t *)in, inLen, nullptr, nullptr);
541 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
542
543 uint8_t *out = nullptr;
544 ret = DataCompress((uint8_t *)in, inLen, &out, nullptr);
545 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
546
547 uint32_t outLen = 0;
548 ret = DataCompress((uint8_t *)in, inLen, &out, &outLen);
549 EXPECT_EQ(ret, SOFTBUS_DEFLATE_FAIL);
550 }
551
552 /*
553 * @tc.name: DATA_DE_COMPRESS_TEST_001
554 * @tc.desc: data decompress test
555 * @tc.type: FUNC
556 * @tc.require:
557 */
558 HWTEST_F(BusCenterUtilsTest, DATA_DE_COMPRESS_TEST_001, TestSize.Level1)
559 {
560 int32_t ret = DataDecompress(nullptr, 0, nullptr, nullptr);
561 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
562
563 char in[] = "123txt321";
564 ret = DataDecompress((uint8_t *)in, 0, nullptr, nullptr);
565 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
566
567 uint32_t inLen = strlen(in);
568 ret = DataDecompress((uint8_t *)in, inLen, nullptr, nullptr);
569 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
570
571 uint8_t *out = nullptr;
572 ret = DataDecompress((uint8_t *)in, inLen, &out, nullptr);
573 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
574 }
575
576 /*
577 * @tc.name: LNN_FSM_POST_MESSAGE_DELAY_TEST_001
578 * @tc.desc: lnn fsm post message delay test
579 * @tc.type: FUNC
580 * @tc.require:
581 */
582 HWTEST_F(BusCenterUtilsTest, LNN_FSM_POST_MESSAGE_DELAY_TEST_001, TestSize.Level1)
583 {
584 int32_t ret = LnnFsmPostMessageDelay(nullptr, FSM_MSG_TYPE_JOIN_LNN_TIMEOUT, nullptr, 0);
585 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
586
587 FsmStateMachine *fsm = (FsmStateMachine *)SoftBusCalloc(sizeof(FsmStateMachine));
588 ASSERT_NE(fsm, nullptr);
589 fsm->looper = nullptr;
590 ret = LnnFsmPostMessageDelay(fsm, FSM_MSG_TYPE_JOIN_LNN_TIMEOUT, nullptr, 0);
591 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
592
593 SoftBusLooper loop;
594 fsm->looper = &loop;
595 fsm->looper->PostMessageDelay = nullptr;
596 ret = LnnFsmPostMessageDelay(fsm, FSM_MSG_TYPE_JOIN_LNN_TIMEOUT, nullptr, 0);
597 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
598
599 fsm->looper->PostMessageDelay = LooperPostMessageDelay;
600 ret = LnnFsmPostMessageDelay(fsm, FSM_MSG_TYPE_JOIN_LNN_TIMEOUT, nullptr, 0);
601 EXPECT_EQ(ret, SOFTBUS_OK);
602
603 SoftBusFree(fsm);
604 }
605
606 /*
607 * @tc.name: LNN_FSM_REMOVE_MESSAGE_BY_TYPE_TEST_001
608 * @tc.desc: lnn fsm remove message by type test
609 * @tc.type: FUNC
610 * @tc.require:
611 */
612 HWTEST_F(BusCenterUtilsTest, LNN_FSM_REMOVE_MESSAGE_BY_TYPE_TEST_001, TestSize.Level1)
613 {
614 int32_t ret = LnnFsmRemoveMessageByType(nullptr, FSM_CTRL_MSG_START);
615 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
616
617 SoftBusLooper loop;
618 FsmStateMachine *fsm = (FsmStateMachine *)SoftBusCalloc(sizeof(FsmStateMachine));
619 ASSERT_NE(fsm, nullptr);
620 fsm->looper = nullptr;
621 ret = LnnFsmRemoveMessageByType(fsm, FSM_CTRL_MSG_START);
622 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
623
624 fsm->looper = &loop;
625 fsm->looper->RemoveMessage = nullptr;
626 ret = LnnFsmRemoveMessageByType(fsm, FSM_CTRL_MSG_START);
627 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
628
629 fsm->looper->RemoveMessage = LooperRemoveMessage;
630 fsm->handler = g_buscenterUtilsHandler;
631 ret = LnnFsmRemoveMessageByType(fsm, FSM_CTRL_MSG_START);
632 EXPECT_EQ(ret, SOFTBUS_OK);
633
634 SoftBusFree(fsm);
635 }
636
637 /*
638 * @tc.name: LNN_FSM_REMOVE_MESSAGE_TEST_001
639 * @tc.desc: lnn fsm remove message test
640 * @tc.type: FUNC
641 * @tc.require:
642 */
643 HWTEST_F(BusCenterUtilsTest, LNN_FSM_REMOVE_MESSAGE_TEST_001, TestSize.Level1)
644 {
645 int32_t ret = LnnFsmRemoveMessage(nullptr, FSM_MSG_TYPE_JOIN_LNN_TIMEOUT);
646 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
647
648 FsmStateMachine *fsm = (FsmStateMachine *)SoftBusCalloc(sizeof(FsmStateMachine));
649 ASSERT_NE(fsm, nullptr);
650 fsm->looper = nullptr;
651 ret = LnnFsmRemoveMessage(fsm, FSM_MSG_TYPE_JOIN_LNN_TIMEOUT);
652 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
653
654 SoftBusLooper loop;
655 fsm->looper = &loop;
656 fsm->looper->RemoveMessageCustom = nullptr;
657 ret = LnnFsmRemoveMessage(fsm, FSM_MSG_TYPE_JOIN_LNN_TIMEOUT);
658 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
659
660 fsm->looper->RemoveMessageCustom = LoopRemoveMessageCustom;
661 fsm->handler = g_buscenterUtilsHandler;
662 ret = LnnFsmRemoveMessage(fsm, FSM_MSG_TYPE_JOIN_LNN_TIMEOUT);
663 EXPECT_EQ(ret, SOFTBUS_OK);
664 SoftBusFree(fsm);
665 }
666
667 /*
668 * @tc.name: LNN_MAP_NEXT_TEST_001
669 * @tc.desc: lnn map next test
670 * @tc.type: FUNC
671 * @tc.require:
672 */
673 HWTEST_F(BusCenterUtilsTest, LNN_MAP_NEXT_TEST_001, TestSize.Level1)
674 {
675 MapIterator *ret = LnnMapNext(nullptr);
676 EXPECT_EQ(ret, nullptr);
677
678 MapIterator *it = (MapIterator *)SoftBusCalloc(sizeof(MapIterator));
679 ASSERT_NE(it, nullptr);
680 it->map = (Map *)SoftBusCalloc(sizeof(Map));
681 if (it->map == nullptr) {
682 SoftBusFree(it);
683 return;
684 }
685 it->map->nodeSize = HDF_MAP_VALUE_MAX_SIZE + 1;
686 it->nodeNum = 1;
687 it->node = (MapNode *)SoftBusCalloc(sizeof(MapNode));
688 if (it->node == nullptr) {
689 SoftBusFree(it->map);
690 SoftBusFree(it);
691 return;
692 }
693 it->node->next = (MapNode *)SoftBusCalloc(sizeof(MapNode));
694 if (it->node->next == nullptr) {
695 SoftBusFree(it->node);
696 SoftBusFree(it->map);
697 SoftBusFree(it);
698 return;
699 }
700 ret = LnnMapNext(it);
701 EXPECT_NE(ret, nullptr);
702
703 it->map->nodeSize = HDF_MAP_VALUE_MAX_SIZE;
704 it->nodeNum = HDF_MAP_VALUE_MAX_SIZE;
705 ret = LnnMapNext(it);
706 EXPECT_NE(ret, nullptr);
707
708 SoftBusFree(it->node->next);
709 SoftBusFree(it->node);
710 SoftBusFree(it->map);
711 SoftBusFree(it);
712 }
713 } // namespace OHOS