• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 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 "iservice_registry.h"
17 #include "system_ability_definition.h"
18 #include <gtest/gtest.h>
19 
20 #include "auth_log.h"
21 #include "disc_coap_capability_public.h"
22 #include "g_enhance_adapter_func.h"
23 #include "g_enhance_adapter_func_pack.h"
24 #include "g_enhance_auth_func.h"
25 #include "g_enhance_auth_func_pack.h"
26 #include "g_enhance_conn_func.h"
27 #include "g_enhance_conn_func_pack.h"
28 #include "g_enhance_disc_func.h"
29 #include "g_enhance_disc_func_pack.h"
30 #include "g_enhance_lnn_func.h"
31 #include "g_enhance_lnn_func_pack.h"
32 #include "g_enhance_trans_func.h"
33 #include "g_enhance_trans_func_pack.h"
34 #include "lnn_heartbeat_medium_mgr.h"
35 #include "lnn_heartbeat_utils_struct.h"
36 #include "lnn_secure_storage_struct.h"
37 #include "softbus_broadcast_manager.h"
38 #include "softbus_error_code.h"
39 #include "softbus_init_common.h"
40 #include "softbus_server_frame.h"
41 
42 using namespace testing;
43 using namespace testing::ext;
44 
45 namespace OHOS {
46 
47 #define TEST_SHORT_UDID_HASH_HEX_LEN 16
48 #define VIRTUAL_DEFAULT_SCORE 60
49 #define TEST_PID 1570
50 
51 static const char *TEST_PKG_NAME = "TEST_PKG_NAME";
52 static const char *TEST_UDID = "11223344";
53 static const char *TEST_NETWORK_ID = "11223344";
54 
55 class SoftbusGEnhanceTest : public testing::Test {
56 public:
SoftbusGEnhanceTest()57     SoftbusGEnhanceTest()
58     {}
~SoftbusGEnhanceTest()59     ~SoftbusGEnhanceTest()
60     {}
SetUpTestCase()61     static void SetUpTestCase()
62     {}
TearDownTestCase()63     static void TearDownTestCase()
64     {}
SetUp()65     void SetUp() override
66     {}
TearDown()67     void TearDown() override
68     {}
69 };
70 
71 /**
72  * @tc.name: InitSoftbusPagingPacked001
73  * @tc.desc: AdapterRegisterEnhanceFunc function test
74  * @tc.type: FUNC
75  * @tc.require:
76  */
77 HWTEST_F(SoftbusGEnhanceTest, InitSoftbusPagingPacked001, TestSize.Level1)
78 {
79     ProxyChannelInfo info;
80     int32_t ret = InitSoftbusPagingPacked();
81     EXPECT_EQ(ret, SOFTBUS_OK);
82     DeInitSoftbusPagingPacked();
83     TransPagingDeathCallbackPacked(TEST_PKG_NAME, TEST_PID);
84     TransHasAndUpdatePagingListenPacked(&info);
85 }
86 
87 /**
88  * @tc.name: TransReversePullUpPackedTest001
89  * @tc.desc: AdapterRegisterEnhanceFunc function test
90  * @tc.type: FUNC
91  * @tc.require:
92  */
93 HWTEST_F(SoftbusGEnhanceTest, TransReversePullUpPackedTest001, TestSize.Level1)
94 {
95     uint32_t chatMode = 1;
96     uint32_t businessFlag = 1;
97     char *pkgName = const_cast<char *>(TEST_PKG_NAME);
98     int32_t ret = TransReversePullUpPacked(chatMode, businessFlag, pkgName);
99     EXPECT_EQ(ret, SOFTBUS_OK);
100 }
101 
102 /**
103  * @tc.name: TransGetPkgnameByBusinessFlagPackedTest001
104  * @tc.desc: AdapterRegisterEnhanceFunc function test
105  * @tc.type: FUNC
106  * @tc.require:
107  */
108 HWTEST_F(SoftbusGEnhanceTest, TransGetPkgnameByBusinessFlagPackedTest001, TestSize.Level1)
109 {
110     uint32_t pkgLen = 1;
111     uint32_t businessFlag = 1;
112     char *pkgName = const_cast<char *>(TEST_PKG_NAME);
113     int32_t ret = TransGetPkgnameByBusinessFlagPacked(businessFlag, pkgName, pkgLen);
114     EXPECT_EQ(ret, SOFTBUS_OK);
115 }
116 
117 /**
118  * @tc.name: TransPagingGetPidAndDataByFlgPackedTest001
119  * @tc.desc: AdapterRegisterEnhanceFunc function test
120  * @tc.type: FUNC
121  * @tc.require:
122  */
123 HWTEST_F(SoftbusGEnhanceTest, TransPagingGetPidAndDataByFlgPackedTest001, TestSize.Level1)
124 {
125     bool isClient = true;
126     uint32_t businessFlag = 1;
127     int32_t pid = 1;
128     uint32_t len = 1;
129     char *data = const_cast<char *>(TEST_PKG_NAME);
130     int32_t ret = TransPagingGetPidAndDataByFlgPacked(isClient, businessFlag, &pid, data, &len);
131     EXPECT_EQ(ret, SOFTBUS_OK);
132 }
133 
134 /**
135  * @tc.name: SoftbusGEnhanceTest001
136  * @tc.desc: AdapterRegisterEnhanceFunc function test
137  * @tc.type: FUNC
138  * @tc.require:
139  */
140 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest001, TestSize.Level1)
141 {
142     AdapterEnhanceFuncListGet();
143     int32_t ret = AdapterRegisterEnhanceFunc(nullptr);
144     EXPECT_EQ(ret, SOFTBUS_OK);
145 }
146 
147 /**
148  * @tc.name: SoftbusGEnhanceTest002
149  * @tc.desc: AuthRegisterEnhanceFunc function test
150  * @tc.type: FUNC
151  * @tc.require:
152  */
153 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest002, TestSize.Level1)
154 {
155     AuthEnhanceFuncListGet();
156     int32_t ret = AuthRegisterEnhanceFunc(nullptr);
157     EXPECT_EQ(ret, SOFTBUS_OK);
158 }
159 
160 /**
161  * @tc.name: SoftbusGEnhanceTest003
162  * @tc.desc: ConnRegisterEnhanceFunc function test
163  * @tc.type: FUNC
164  * @tc.require:
165  */
166 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest003, TestSize.Level1)
167 {
168     ConnEnhanceFuncListGet();
169     int32_t ret = ConnRegisterEnhanceFunc(nullptr);
170     EXPECT_EQ(ret, SOFTBUS_OK);
171 }
172 
173 /**
174  * @tc.name: SoftbusGEnhanceTest004
175  * @tc.desc: DiscRegisterEnhanceFunc function test
176  * @tc.type: FUNC
177  * @tc.require:
178  */
179 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest004, TestSize.Level1)
180 {
181     DiscEnhanceFuncListGet();
182     int32_t ret = DiscRegisterEnhanceFunc(nullptr);
183     EXPECT_EQ(ret, SOFTBUS_OK);
184 }
185 
186 /**
187  * @tc.name: SoftbusGEnhanceTest005
188  * @tc.desc: LnnRegisterEnhanceFunc function test
189  * @tc.type: FUNC
190  * @tc.require:
191  */
192 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest005, TestSize.Level1)
193 {
194     LnnEnhanceFuncListGet();
195     int32_t ret = LnnRegisterEnhanceFunc(nullptr);
196     EXPECT_EQ(ret, SOFTBUS_OK);
197 }
198 
199 /**
200  * @tc.name: SoftbusGEnhanceTest006
201  * @tc.desc: LnnRegisterEnhanceFunc function test
202  * @tc.type: FUNC
203  * @tc.require:
204  */
205 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest006, TestSize.Level1)
206 {
207     TransEnhanceFuncListGet();
208     int32_t ret = TransRegisterEnhanceFunc(nullptr);
209     EXPECT_EQ(ret, SOFTBUS_OK);
210 }
211 
212 /**
213  * @tc.name: SoftbusGEnhanceTest007
214  * @tc.desc: Auth function test
215  * @tc.type: FUNC
216  * @tc.require:
217  */
218 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest007, TestSize.Level1)
219 {
220     char udidShortHash[TEST_SHORT_UDID_HASH_HEX_LEN + 1] = { 0 };
221     AuthLinkType type = AUTH_LINK_TYPE_MAX;
222     AuthUpdateNormalizeKeyIndexPacked(udidShortHash, 0, type, nullptr, 0);
223     int32_t ret = GenerateCertificatePacked(nullptr, nullptr);
224     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
225     ret = IsNeedUDIDAbatementPacked(nullptr);
226     EXPECT_EQ(ret, false);
227     ret = VerifyCertificatePacked(nullptr, nullptr, nullptr);
228     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
229     AuthMetaNotifyDataReceivedPacked(0, nullptr, nullptr);
230     AuthClearDeviceKeyPacked();
231     DelAuthMetaManagerByConnectionIdPacked(0);
232 }
233 
234 /**
235  * @tc.name: SoftbusGEnhanceTest008
236  * @tc.desc: Conn function test
237  * @tc.type: FUNC
238  * @tc.require:
239  */
240 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest008, TestSize.Level1)
241 {
242     int32_t ret = ConnCoapStartServerListenPacked();
243     EXPECT_EQ(ret, SOFTBUS_FUNC_NOT_SUPPORT);
244     ConnCoapStopServerListenPacked();
245     SoftbusBleConflictNotifyDisconnectPacked(nullptr, nullptr);
246     SoftbusBleConflictNotifyDateReceivePacked(0, nullptr, 0);
247     SoftbusBleConflictNotifyConnectResultPacked(0, 0, 0);
248     SoftbusBleConflictRegisterListenerPacked(nullptr);
249     ret = ConnBleDirectInitPacked();
250     EXPECT_EQ(ret, SOFTBUS_OK);
251     BleProtocolType protocol = BLE_PROTOCOL_MAX;
252     ret = ConnBleDirectIsEnablePacked(protocol);
253     EXPECT_EQ(ret, false);
254     ret = ConnBleDirectConnectDevicePacked(nullptr, 0, nullptr);
255     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
256     ret = ConnDirectConnectDevicePacked(nullptr, 0, nullptr);
257     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
258 }
259 
260 /**
261  * @tc.name: SoftbusGEnhanceTest009
262  * @tc.desc: Trans function test
263  * @tc.type: FUNC
264  * @tc.require:
265  */
266 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest009, TestSize.Level1)
267 {
268     int32_t ret = SetDefaultQdiscPacked();
269     EXPECT_EQ(ret, SOFTBUS_OK);
270     ret = InitQosPacked();
271     EXPECT_EQ(ret, SOFTBUS_OK);
272     NotifyQosChannelClosedPacked(0, 0);
273     GetExtQosInfoPacked(nullptr, nullptr, 0, nullptr);
274     ret = NotifyQosChannelOpenedPacked(nullptr);
275     EXPECT_EQ(ret, SOFTBUS_OK);
276 }
277 
278 /**
279  * @tc.name: SoftbusGEnhanceTest010
280  * @tc.desc: Lnn0 function test
281  * @tc.type: FUNC
282  * @tc.require:
283  */
284 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest010, TestSize.Level1)
285 {
286     int32_t ret = AuthMetaOpenConnPacked(nullptr, 0, nullptr);
287     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
288     ret = AuthMetaPostTransDataPacked(0, nullptr);
289     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
290     AuthMetaCloseConnPacked(0);
291     ret = AuthMetaGetPreferConnInfoPacked(nullptr, nullptr);
292     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
293     ret = AuthMetaGetIdByConnInfoPacked(nullptr, 0);
294     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
295     ret = AuthMetaGetIdByUuidPacked(nullptr, AUTH_LINK_TYPE_MAX, 0);
296     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
297     ret = AuthMetaEncryptPacked(0, nullptr, 0, nullptr, nullptr);
298     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
299     ret = AuthMetaDecryptPacked(0, nullptr, 0, nullptr, nullptr);
300     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
301     ret = AuthMetaSetP2pMacPacked(0, nullptr);
302     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
303     ret = AuthMetaGetConnInfoPacked(0, nullptr);
304     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
305     ret = AuthMetaGetDeviceUuidPacked(0, nullptr, 0);
306     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
307     ret = AuthMetaGetServerSidePacked(0, nullptr);
308     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
309     AuthMetaCheckMetaExistPacked(nullptr, nullptr);
310     ret = CustomizedSecurityProtocolInitPacked();
311     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
312     CustomizedSecurityProtocolDeinitPacked();
313     AuthMetaDeinitPacked();
314     DelAuthMetaManagerByPidPacked(nullptr, 0);
315     ClearMetaNodeRequestByPidPacked(nullptr, 0);
316     LnnClearAuthExchangeUdidPacked(nullptr);
317     ret = AuthInsertDeviceKeyPacked(nullptr, nullptr, AUTH_LINK_TYPE_MAX);
318     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
319     AuthUpdateKeyIndexPacked(nullptr, 0, 0, 0);
320     ret = LnnGenerateLocalPtkPacked(nullptr, nullptr);
321     EXPECT_EQ(ret, SOFTBUS_OK);
322 }
323 
324 /**
325  * @tc.name: SoftbusGEnhanceTest011
326  * @tc.desc: Lnn1 function test
327  * @tc.type: FUNC
328  * @tc.require:
329  */
330 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest011, TestSize.Level1)
331 {
332     int32_t ret = CalcHKDFPacked(nullptr, 0, nullptr, 0);
333     EXPECT_EQ(ret, false);
334     AuthUpdateCreateTimePacked(nullptr, 0, 0);
335     ret = AuthFindNormalizeKeyByServerSidePacked(nullptr, 0, nullptr);
336     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
337     ret = IsSupportUDIDAbatementPacked();
338     EXPECT_EQ(ret, false);
339     ret = AuthMetaGetConnIdByInfoPacked(nullptr, nullptr);
340     EXPECT_EQ(ret, SOFTBUS_OK);
341     ret = LnnGetMetaPtkPacked(0, nullptr, 0);
342     EXPECT_EQ(ret, SOFTBUS_OK);
343     ret = PackCipherKeySyncMsgPacked(nullptr);
344     EXPECT_EQ(ret, true);
345     ProcessCipherKeySyncInfoPacked(nullptr, nullptr);
346     FreeSoftbusChainPacked(nullptr);
347     ret = InitSoftbusChainPacked(nullptr);
348     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
349     ret = LnnSyncTrustedRelationShipPacked(nullptr, nullptr, 0);
350     EXPECT_EQ(ret, SOFTBUS_OK);
351     LnnCoapConnectPacked(nullptr);
352     LnnDestroyCoapConnectListPacked();
353     ret = LnnInitQosPacked();
354     EXPECT_EQ(ret, SOFTBUS_OK);
355     LnnDeinitQosPacked();
356     ret = LnnSyncBleOfflineMsgPacked();
357     EXPECT_EQ(ret, SOFTBUS_OK);
358     LnnBleHbRegDataLevelChangeCbPacked(nullptr);
359     LnnBleHbUnregDataLevelChangeCbPacked();
360     ret = DecryptUserIdPacked(nullptr, nullptr, 0);
361     EXPECT_EQ(ret, SOFTBUS_OK);
362     ret = IsCloudSyncEnabledPacked();
363     EXPECT_EQ(ret, false);
364     ret = AuthFindDeviceKeyPacked(nullptr, 0, nullptr);
365     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
366     ret = AuthFindLatestNormalizeKeyPacked(nullptr, nullptr, 0);
367     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
368     ret = IsCipherManagerFindKeyPk(nullptr);
369     EXPECT_EQ(ret, false);
370     ret = LnnAddRemoteChannelCodePacked(nullptr, 0);
371     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
372     ret = LnnRegistBleHeartbeatMediumMgrPacked();
373     EXPECT_EQ(ret, SOFTBUS_OK);
374     ret = LnnRegisterBleLpDeviceMediumMgrPacked();
375     EXPECT_EQ(ret, SOFTBUS_OK);
376 }
377 
378 /**
379  * @tc.name: SoftbusGEnhanceTest012
380  * @tc.desc: Lnn2 function test
381  * @tc.type: FUNC
382  * @tc.require:
383  */
384 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest012, TestSize.Level1)
385 {
386     int32_t ret = HaveConcurrencyPreLinkReqIdByReuseConnReqIdPacked(0, 0);
387     EXPECT_EQ(ret, false);
388     ret = HaveConcurrencyPreLinkNodeByLaneReqIdPacked(0, 0);
389     EXPECT_EQ(ret, false);
390     ret = GetConcurrencyLaneReqIdByConnReqIdPacked(0, nullptr);
391     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
392     LnnFreePreLinkPacked(nullptr);
393     ret = LnnRequestCheckOnlineStatusPacked(nullptr, 0);
394     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
395     ret = LnnSyncPtkPacked(nullptr);
396     EXPECT_EQ(ret, SOFTBUS_OK);
397     ret = GetConcurrencyLaneReqIdByActionIdPacked(0, nullptr);
398     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
399     ret = UpdateConcurrencyReuseLaneReqIdByActionIdPacked(0, 0, 0);
400     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
401     ret = UpdateConcurrencyReuseLaneReqIdByUdidPacked(nullptr, 0, 0);
402     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
403     ret = LnnAddLocalVapInfoPacked(LNN_VAP_UNKNOWN, nullptr);
404     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
405     ret = LnnDeleteLocalVapInfoPacked(LNN_VAP_UNKNOWN);
406     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
407     DisablePowerControlPacked(nullptr);
408     ret = EnablePowerControlPacked(nullptr);
409     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
410     ret = LnnInitScorePacked();
411     EXPECT_EQ(ret, SOFTBUS_OK);
412     ret = LnnStartScoringPacked(0);
413     EXPECT_EQ(ret, SOFTBUS_OK);
414     ret = LnnInitVapInfoPacked();
415     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
416     LnnDeinitScorePacked();
417     LnnDeinitVapInfoPacked();
418     ret = LnnGetWlanLinkedInfoPacked(nullptr);
419     EXPECT_EQ(ret, SOFTBUS_LANE_SELECT_FAIL);
420     ret = LnnGetCurrChannelScorePacked(0);
421     EXPECT_EQ(ret, VIRTUAL_DEFAULT_SCORE);
422     ret = IsPowerControlEnabledPacked();
423     EXPECT_EQ(ret, false);
424 }
425 
426 /**
427  * @tc.name: SoftbusGEnhanceTest013
428  * @tc.desc: Lnn3 function test
429  * @tc.type: FUNC
430  * @tc.require:
431  */
432 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest013, TestSize.Level1)
433 {
434     int32_t ret = LnnStartTimeSyncImplPacked(nullptr, UNAVAIL_ACCURACY, SHORT_PERIOD, nullptr);
435     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
436     ret = LnnStopTimeSyncImplPacked(nullptr);
437     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
438     ret = LnnTimeSyncImplInitPacked();
439     EXPECT_EQ(ret, SOFTBUS_OK);
440     LnnTimeSyncImplDeinitPacked();
441     SendDeviceStateToMlpsPacked(nullptr);
442     ret = LnnRetrieveDeviceInfoByNetworkIdPacked(nullptr, nullptr);
443     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
444     SetLpKeepAliveStatePacked(nullptr);
445     ret = LnnSetRemoteBroadcastCipherInfoPacked(nullptr, nullptr);
446     EXPECT_EQ(ret, SOFTBUS_OK);
447     ret = LnnGetLocalCacheNodeInfoPacked(nullptr);
448     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
449     LnnDeleteDeviceInfoPacked(nullptr);
450     ret = LnnUnPackCloudSyncDeviceInfoPacked(nullptr, nullptr);
451     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
452     ret = LnnPackCloudSyncDeviceInfoPacked(nullptr, nullptr);
453     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
454     ret = LnnGetLocalBroadcastCipherInfoPacked(nullptr);
455     EXPECT_EQ(ret, SOFTBUS_OK);
456     ret = LnnPackCloudSyncAckSeqPacked(nullptr, nullptr);
457     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
458     ret = LnnInitCipherKeyManagerPacked();
459     EXPECT_EQ(ret, SOFTBUS_OK);
460     ret = LnnSendNotTrustedInfoPacked(nullptr, 0, nullptr);
461     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
462     RegisterOOBEMonitorPacked(nullptr);
463     ret = LnnLinkFinderInitPacked();
464     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
465 }
466 
467 /**
468  * @tc.name: SoftbusGEnhanceTest014
469  * @tc.desc: Lnn4 function test
470  * @tc.type: FUNC
471  * @tc.require:
472  */
473 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest014, TestSize.Level1)
474 {
475     int32_t ret = LnnInitFastOfflinePacked();
476     EXPECT_EQ(ret, SOFTBUS_OK);
477     LnnDeinitFastOfflinePacked();
478     ret = LnnRemoveLinkFinderInfoPacked(nullptr);
479     EXPECT_EQ(ret, SOFTBUS_OK);
480     ret = LnnRetrieveDeviceInfoByUdidPacked(nullptr, nullptr);
481     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
482     ret = LnnInitBroadcastLinkKeyPacked();
483     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
484     ret = LnnInitPtkPacked();
485     EXPECT_EQ(ret, SOFTBUS_OK);
486     LnnDeinitBroadcastLinkKeyPacked();
487     LnnDeinitPtkPacked();
488     LnnIpAddrChangeEventHandlerPacked();
489     LnnInitOOBEStateMonitorImplPacked();
490     EhLoginEventHandlerPacked();
491     ret = LnnInitMetaNodeExtLedgerPacked();
492     EXPECT_EQ(ret, SOFTBUS_OK);
493     ret = IsSupportLpFeaturePacked();
494     EXPECT_EQ(ret, false);
495     AuthLoadDeviceKeyPacked();
496     ret = LnnLoadLocalDeviceInfoPacked();
497     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
498     LnnLoadPtkInfoPacked();
499     ret = LnnLoadRemoteDeviceInfoPacked();
500     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
501     LoadBleBroadcastKeyPacked();
502     LnnClearPtkListPacked();
503     ClearDeviceInfoPacked();
504     ret = GenerateNewLocalCipherKeyPacked();
505     EXPECT_EQ(ret, SOFTBUS_OK);
506     ret = LnnRetrieveDeviceInfoPacked(nullptr, nullptr);
507     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
508     ret = LnnSaveRemoteDeviceInfoPacked(nullptr);
509     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
510     ret = LnnInsertLinkFinderInfoPacked(nullptr);
511     EXPECT_EQ(ret, SOFTBUS_OK);
512     ret = LnnUpdateRemoteDeviceInfoPacked(nullptr);
513     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
514     ret = LnnSaveLocalDeviceInfoPacked(nullptr);
515     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
516 }
517 
518 /**
519  * @tc.name: SoftbusGEnhanceTest015
520  * @tc.desc: Lnn5 function test
521  * @tc.type: FUNC
522  * @tc.require:
523  */
524 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest015, TestSize.Level1)
525 {
526     int32_t ret = LnnGetAccountIdFromLocalCachePacked(nullptr);
527     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
528     ret = LnnGetLocalDevInfoPacked(nullptr);
529     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
530     ret = LnnGetLocalBroadcastCipherKeyPacked(nullptr);
531     EXPECT_EQ(ret, SOFTBUS_OK);
532     ret = LnnLoadLocalBroadcastCipherKeyPacked();
533     EXPECT_EQ(ret, SOFTBUS_OK);
534     ret = LnnUpdateLocalBroadcastCipherKeyPacked(nullptr);
535     EXPECT_EQ(ret, SOFTBUS_OK);
536     ret = HbBuildUserIdCheckSumPacked(nullptr, 0, nullptr, 0);
537     EXPECT_EQ(ret, SOFTBUS_OK);
538     LnnUpdateAuthExchangeUdidPacked();
539     LnnCoapConnectInitPacked();
540     ret = LnnInitMetaNodePacked();
541     EXPECT_EQ(ret, SOFTBUS_OK);
542     ret = InitActionBleConcurrencyPacked();
543     EXPECT_EQ(ret, SOFTBUS_OK);
544     ret = InitActionStateAdapterPacked();
545     EXPECT_EQ(ret, SOFTBUS_OK);
546     ret = LnnLoadLocalDeviceAccountIdInfoPacked();
547     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
548     LnnDeinitMetaNodePacked();
549     LnnCoapConnectDeinitPacked();
550     ret = LnnGetOOBEStatePacked(nullptr);
551     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
552     SoftBusOOBEState state;
553     ret = LnnGetOOBEStatePacked(&state);
554     EXPECT_EQ(ret, SOFTBUS_OK);
555     LnnReportLaneIdStatsInfoPacked(nullptr, 0);
556     ret = LnnRequestQosOptimizationPacked(nullptr, 0, nullptr, 0);
557     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
558     LnnCancelQosOptimizationPacked(nullptr, 0);
559     LnnReportRippleDataPacked(0, nullptr);
560     ret = LnnGetUdidByBrMacPacked(nullptr, nullptr, 0);
561     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
562     AuthRemoveDeviceKeyByUdidPacked(nullptr);
563     ret = LnnGetRecommendChannelPacked(nullptr, nullptr);
564     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
565     ret = LnnGetLocalPtkByUuidPacked(nullptr, nullptr, 0);
566     EXPECT_EQ(ret, SOFTBUS_OK);
567 }
568 
569 /**
570  * @tc.name: SoftbusGEnhanceTest016
571  * @tc.desc: Lnn6 function test
572  * @tc.type: FUNC
573  * @tc.require:
574  */
575 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest016, TestSize.Level1)
576 {
577     int32_t ret = RegistAuthTransListenerPacked();
578     EXPECT_EQ(ret, SOFTBUS_OK);
579     ret = UnregistAuthTransListenerPacked();
580     EXPECT_EQ(ret, SOFTBUS_OK);
581     ret = LnnStartRangePacked(nullptr);
582     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
583     ret = LnnStopRangePacked(nullptr);
584     EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
585     LnnRegSleRangeCbPacked(nullptr);
586     LnnUnregSleRangeCbPacked();
587     SleRangeDeathCallbackPacked();
588     ret = LnnDeviceCloudConvergenceInitPacked();
589     EXPECT_EQ(ret, SOFTBUS_OK);
590     EXPECT_NO_FATAL_FAILURE(CheckNeedCloudSyncOfflinePacked(DISCOVERY_TYPE_BLE));
591     EXPECT_NO_FATAL_FAILURE(CheckNeedCloudSyncOfflinePacked(DISCOVERY_TYPE_WIFI));
592 }
593 
594 /**
595  * @tc.name: SoftbusGEnhanceTest017
596  * @tc.desc: AdapterRegisterEnhanceFunc function test
597  * @tc.type: FUNC
598  * @tc.require:
599  */
600 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest017, TestSize.Level1)
601 {
602     ProxyChannelInfo info;
603     int32_t ret = InitSoftbusPagingPacked();
604     EXPECT_EQ(ret, SOFTBUS_OK);
605     DeInitSoftbusPagingPacked();
606     TransPagingDeathCallbackPacked(TEST_PKG_NAME, TEST_PID);
607     TransHasAndUpdatePagingListenPacked(&info);
608 }
609 
610 /**
611  * @tc.name: SoftbusGEnhanceTest018
612  * @tc.desc: AdapterRegisterEnhanceFunc function test
613  * @tc.type: FUNC
614  * @tc.require:
615  */
616 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest018, TestSize.Level1)
617 {
618     bool isClient = true;
619     uint32_t businessFlag = 1;
620     int32_t pid = 1;
621     uint32_t len = 1;
622     char data[EXTRA_DATA_MAX_LEN] = { 0 };
623     int32_t ret = TransPagingGetPidAndDataByFlgPacked(isClient, businessFlag, &pid, data, &len);
624     EXPECT_EQ(ret, SOFTBUS_OK);
625     ret = TransDelPagingInfoByBusinessFlagPacked(businessFlag);
626     EXPECT_EQ(ret, SOFTBUS_OK);
627 }
628 
629 /**
630  * @tc.name: SoftbusGEnhanceTest019
631  * @tc.desc: AdapterRegisterEnhanceFunc function test
632  * @tc.type: FUNC
633  * @tc.require:
634  */
635 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest019, TestSize.Level1)
636 {
637     uint32_t chatMode = 1;
638     uint32_t businessFlag = 1;
639     char *pkgName = const_cast<char *>(TEST_PKG_NAME);
640     int32_t ret = TransReversePullUpPacked(chatMode, businessFlag, pkgName);
641     EXPECT_EQ(ret, SOFTBUS_OK);
642 }
643 
644 /**
645  * @tc.name: SoftbusGEnhanceTest020
646  * @tc.desc: AdapterRegisterEnhanceFunc function test
647  * @tc.type: FUNC
648  * @tc.require:
649  */
650 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest020, TestSize.Level1)
651 {
652     uint32_t pkgLen = 1;
653     uint32_t businessFlag = 1;
654     char *pkgName = const_cast<char *>(TEST_PKG_NAME);
655     int32_t ret = TransGetPkgnameByBusinessFlagPacked(businessFlag, pkgName, pkgLen);
656     EXPECT_EQ(ret, SOFTBUS_OK);
657 }
658 
659 /**
660  * @tc.name: SoftbusGEnhanceTest021
661  * @tc.desc: AdapterRegisterEnhanceFunc function test
662  * @tc.type: FUNC
663  * @tc.require:
664  */
665 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest021, TestSize.Level1)
666 {
667     bool isClient = true;
668     uint32_t businessFlag = 1;
669     int32_t pid = 1;
670     uint32_t len = 1;
671     char *data = const_cast<char *>(TEST_PKG_NAME);
672     int32_t ret = TransPagingGetPidAndDataByFlgPacked(isClient, businessFlag, &pid, data, &len);
673     EXPECT_EQ(ret, SOFTBUS_OK);
674 }
675 
676 /**
677  * @tc.name: SoftbusGEnhanceTest022
678  * @tc.desc: SparkGroupEnhanceFunc function test
679  * @tc.type: FUNC
680  * @tc.require:
681  */
682 HWTEST_F(SoftbusGEnhanceTest, SoftbusGEnhanceTest022, TestSize.Level1)
683 {
684     EXPECT_NO_FATAL_FAILURE(TriggerSparkGroupBuildPacked(0));
685     EXPECT_NO_FATAL_FAILURE(TriggerSparkGroupClearPacked(0, 0));
686     char *udid = const_cast<char *>(TEST_UDID);
687     EXPECT_NO_FATAL_FAILURE(TriggerSparkGroupJoinAgainPacked(udid, 0));
688     EXPECT_EQ(InitControlPlanePacked(), SOFTBUS_OK);
689     EXPECT_NO_FATAL_FAILURE(DeinitControlPlanePacked());
690     char *networkId = const_cast<char *>(TEST_NETWORK_ID);
691     EXPECT_EQ(QueryControlPlaneNodeValidPacked(networkId), SOFTBUS_NOT_IMPLEMENT);
692     EXPECT_EQ(LnnDumpControlLaneGroupInfoPacked(0), SOFTBUS_OK);
693     EXPECT_FALSE(IsSparkGroupEnabledPacked());
694 }
695 
696 /**
697  * @tc.name: IsInWhitelistPacked023
698  * @tc.desc: IsInWhitelistPacked function test
699  * @tc.type: FUNC
700  * @tc.require:
701  */
702 HWTEST_F(SoftbusGEnhanceTest, IsInWhitelistPacked023, TestSize.Level1)
703 {
704     const char *appName = "ohos.samples.distributedmusicplayer";
705     bool ret = IsInWhitelistPacked(appName);
706     EXPECT_EQ(ret, true);
707 }
708 }
709