• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2023-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 <cstddef>
17 #include <cstdlib>
18 #include <cstring>
19 #include <gtest/gtest.h>
20 #include <securec.h>
21 
22 #include "bus_center_info_key.h"
23 #include "bus_center_manager.h"
24 #include "lnn_local_ledger_deps_mock.h"
25 #include "lnn_local_net_ledger.c"
26 #include "lnn_local_net_ledger.h"
27 #include "lnn_log.h"
28 #include "lnn_node_info.h"
29 #include "softbus_adapter_mem.h"
30 #include "softbus_common.h"
31 #include "softbus_error_code.h"
32 
33 namespace OHOS {
34 using namespace testing::ext;
35 constexpr uint32_t CAPABILTY = 17;
36 constexpr uint64_t FEATURE = 1;
37 using namespace testing;
38 class LNNLedgerMockTest : public testing::Test {
39 public:
40     static void SetUpTestCase();
41     static void TearDownTestCase();
42     void SetUp();
43     void TearDown();
44 };
45 
SetUpTestCase()46 void LNNLedgerMockTest::SetUpTestCase() { }
47 
TearDownTestCase()48 void LNNLedgerMockTest::TearDownTestCase() { }
49 
SetUp()50 void LNNLedgerMockTest::SetUp()
51 {
52     LNN_LOGI(LNN_TEST, "LNNLedgerMockTest start");
53 }
54 
TearDown()55 void LNNLedgerMockTest::TearDown() { }
56 
LocalLedgerKeyTestPackaged(void)57 static void LocalLedgerKeyTestPackaged(void)
58 {
59     EXPECT_EQ(UpdateLocalDeviceUdid(nullptr), SOFTBUS_INVALID_PARAM);
60     EXPECT_EQ(UpdateLocalNetworkId(nullptr), SOFTBUS_INVALID_PARAM);
61     EXPECT_EQ(UpdateLocalUuid(nullptr), SOFTBUS_INVALID_PARAM);
62     EXPECT_EQ(UpdateLocalDeviceType(nullptr), SOFTBUS_INVALID_PARAM);
63     EXPECT_EQ(UpdateLocalDeviceName(nullptr), SOFTBUS_INVALID_PARAM);
64     EXPECT_EQ(UpdateUnifiedName(nullptr), SOFTBUS_INVALID_PARAM);
65     EXPECT_EQ(UpdateUnifiedDefaultName(nullptr), SOFTBUS_INVALID_PARAM);
66     EXPECT_EQ(UpdateNickName(nullptr), SOFTBUS_INVALID_PARAM);
67     EXPECT_EQ(UpdateLocalBtMac(nullptr), SOFTBUS_INVALID_PARAM);
68     EXPECT_EQ(UpdateLocalDeviceIp(nullptr, 0), SOFTBUS_INVALID_PARAM);
69     EXPECT_EQ(UpdateLocalNetIfName(nullptr, 0), SOFTBUS_INVALID_PARAM);
70     EXPECT_EQ(LlUpdateNodeAddr(nullptr), SOFTBUS_INVALID_PARAM);
71     EXPECT_EQ(UpdateP2pMac(nullptr), SOFTBUS_INVALID_PARAM);
72     EXPECT_EQ(UpdateWifiCfg(nullptr), SOFTBUS_INVALID_PARAM);
73     EXPECT_EQ(UpdateChanList5g(nullptr), SOFTBUS_INVALID_PARAM);
74     EXPECT_EQ(UpdateP2pGoMac(nullptr), SOFTBUS_INVALID_PARAM);
75     EXPECT_EQ(LlUpdateLocalOffLineCode(nullptr), SOFTBUS_INVALID_PARAM);
76     EXPECT_EQ(LlUpdateLocalExtData(nullptr), SOFTBUS_INVALID_PARAM);
77     EXPECT_EQ(UpdateWifiDirectAddr(nullptr), SOFTBUS_INVALID_PARAM);
78     EXPECT_EQ(LlUpdateLocalP2pIp(nullptr), SOFTBUS_INVALID_PARAM);
79     EXPECT_EQ(UpdateLocalSessionPort(nullptr, 0), SOFTBUS_INVALID_PARAM);
80     EXPECT_EQ(UpdateLocalAuthPort(nullptr, 0), SOFTBUS_INVALID_PARAM);
81     EXPECT_EQ(UpdateLocalProxyPort(nullptr, 0), SOFTBUS_INVALID_PARAM);
82     EXPECT_EQ(UpdateLocalNetCapability(nullptr), SOFTBUS_INVALID_PARAM);
83     EXPECT_EQ(UpdateLocalFeatureCapability(nullptr), SOFTBUS_INVALID_PARAM);
84     EXPECT_EQ(UpdateLocalCipherInfoKey(nullptr), SOFTBUS_INVALID_PARAM);
85     EXPECT_EQ(UpdateLocalCipherInfoIv(nullptr), SOFTBUS_INVALID_PARAM);
86     EXPECT_EQ(LlUpdateStaticCapLen(nullptr), SOFTBUS_INVALID_PARAM);
87     EXPECT_EQ(LlUpdateAccount(nullptr), SOFTBUS_INVALID_PARAM);
88     EXPECT_EQ(LlUpdateStaticCapability(nullptr), SOFTBUS_INVALID_PARAM);
89     EXPECT_EQ(LnnUpdateLocalScreenStatus(true), SOFTBUS_OK);
90     EXPECT_EQ(UpdateHuksKeyTime(nullptr), SOFTBUS_INVALID_PARAM);
91 }
92 
93 /*
94  * @tc.name: LOCAL_LEDGER_MOCK_Test_001
95  * @tc.desc: local ledger init test
96  * @tc.type: FUNC
97  * @tc.require:
98  */
99 HWTEST_F(LNNLedgerMockTest, LOCAL_LEDGER_MOCK_Test_001, TestSize.Level1)
100 {
101     LocalLedgerDepsInterfaceMock localLedgerMock;
102     EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
103     EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _))
104         .WillRepeatedly(Return(SOFTBUS_GENERATE_RANDOM_ARRAY_FAIL));
105     EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
106     EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_NETWORK_LEDGER_INIT_FAILED);
107 }
108 
109 /*
110  * @tc.name: LOCAL_LEDGER_MOCK_Test_002
111  * @tc.desc: local ledger init and deinit test
112  * @tc.type: FUNC
113  * @tc.require:
114  */
115 HWTEST_F(LNNLedgerMockTest, LOCAL_LEDGER_MOCK_Test_002, TestSize.Level1)
116 {
117     NiceMock<LocalLedgerDepsInterfaceMock> localLedgerMock;
118     EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
119     EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
120     EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
121     ON_CALL(localLedgerMock, GetCommonOsType).WillByDefault(Return(SOFTBUS_OK));
122     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, NotNull(), _))
123         .WillRepeatedly(localLedgerMock.LedgerGetCommonDevInfo);
124     EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
125     EXPECT_CALL(localLedgerMock, SoftBusRegBusCenterVarDump(_, _))
126         .WillRepeatedly(localLedgerMock.LedgerSoftBusRegBusCenterVarDump);
127     int32_t ret = LnnInitLocalLedger();
128     EXPECT_TRUE(ret == SOFTBUS_OK);
129     ret = LnnInitLocalLedger();
130     EXPECT_TRUE(ret == SOFTBUS_OK);
131     LnnDeinitLocalLedger();
132 }
133 
134 /*
135  * @tc.name: LOCAL_LEDGER_MOCK_Test_003
136  * @tc.desc: local ledger delay init test
137  * @tc.type: FUNC
138  * @tc.require:
139  */
140 HWTEST_F(LNNLedgerMockTest, LOCAL_LEDGER_MOCK_Test_003, TestSize.Level1)
141 {
142     SoftBusMutexInit(&g_localNetLedger.lock, NULL);
143     LocalLedgerDepsInterfaceMock localLedgerMock;
144     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _))
145         .WillRepeatedly(Return(SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR));
146     EXPECT_CALL(localLedgerMock, LnnInitOhosAccount())
147         .WillRepeatedly(Return(SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR));
148     EXPECT_TRUE(LnnInitLocalLedgerDelay() == SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR);
149 }
150 
151 /*
152  * @tc.name: LOCAL_LEDGER_MOCK_Test_004
153  * @tc.desc: local ledger init test
154  * @tc.type: FUNC
155  * @tc.require:
156  */
157 HWTEST_F(LNNLedgerMockTest, LOCAL_LEDGER_MOCK_Test_004, TestSize.Level1)
158 {
159     LocalLedgerDepsInterfaceMock localLedgerMock;
160     EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
161     EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
162     EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
163     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _))
164         .WillRepeatedly(Return(SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR));
165     EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
166     EXPECT_CALL(localLedgerMock, SoftBusRegBusCenterVarDump(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
167     EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_NETWORK_LEDGER_INIT_FAILED);
168 }
169 
170 /*
171  * @tc.name: LOCAL_LEDGER_MOCK_Test_005
172  * @tc.desc: local ledger init test
173  * @tc.type: FUNC
174  * @tc.require:
175  */
176 HWTEST_F(LNNLedgerMockTest, LOCAL_LEDGER_MOCK_Test_005, TestSize.Level1)
177 {
178     LocalLedgerDepsInterfaceMock localLedgerMock;
179     EXPECT_CALL(localLedgerMock, GetCommonDeviceVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
180     EXPECT_CALL(localLedgerMock, GetDeviceSecurityLevel(_)).WillRepeatedly(Return(SOFTBUS_OK));
181     EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
182     EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
183     EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
184     EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
185     EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
186     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
187     EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_SET_P2P_INFO_FAIL));
188     EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_NETWORK_LEDGER_INIT_FAILED);
189 }
190 
191 /*
192  * @tc.name: LOCAL_LEDGER_MOCK_Test_006
193  * @tc.desc: local ledger init test
194  * @tc.type: FUNC
195  * @tc.require:
196  */
197 HWTEST_F(LNNLedgerMockTest, LOCAL_LEDGER_MOCK_Test_006, TestSize.Level1)
198 {
199     LocalLedgerDepsInterfaceMock localLedgerMock;
200     EXPECT_CALL(localLedgerMock, GetCommonDeviceVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
201     EXPECT_CALL(localLedgerMock, GetDeviceSecurityLevel(_)).WillRepeatedly(Return(SOFTBUS_OK));
202     EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
203     EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
204     EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
205     EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
206     EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
207     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
208     EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
209     EXPECT_CALL(localLedgerMock, SoftBusRegBusCenterVarDump(_, _)).WillRepeatedly(Return(SOFTBUS_MEM_ERR));
210     EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_MEM_ERR);
211 }
212 
213 /*
214  * @tc.name: LOCAL_LEDGER_MOCK_Test_007
215  * @tc.desc: local ledger init test
216  * @tc.type: FUNC
217  * @tc.require:
218  */
219 HWTEST_F(LNNLedgerMockTest, LOCAL_LEDGER_MOCK_Test_007, TestSize.Level1)
220 {
221     LocalLedgerDepsInterfaceMock localLedgerMock;
222     EXPECT_CALL(localLedgerMock, GetCommonDeviceVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
223     EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
224     EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
225     EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
226     EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
227     EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
228     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _))
229         .WillOnce(Return(SOFTBUS_OK))
230         .WillRepeatedly(Return(SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR));
231     EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
232     EXPECT_CALL(localLedgerMock, SoftBusRegBusCenterVarDump(_, _)).WillRepeatedly(Return(SOFTBUS_MEM_ERR));
233     EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_NETWORK_LEDGER_INIT_FAILED);
234 }
235 
236 /*
237  * @tc.name: LOCAL_LEDGER_MOCK_Test_008
238  * @tc.desc: local ledger init test
239  * @tc.type: FUNC
240  * @tc.require:
241  */
242 HWTEST_F(LNNLedgerMockTest, LOCAL_LEDGER_MOCK_Test_008, TestSize.Level1)
243 {
244     LocalLedgerDepsInterfaceMock localLedgerMock;
245     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
246     EXPECT_CALL(localLedgerMock, LnnInitOhosAccount())
247         .WillRepeatedly(Return(SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR));
248     EXPECT_TRUE(LnnInitLocalLedgerDelay() == SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR);
249 }
250 
251 /*
252  * @tc.name: LOCAL_LEDGER_MOCK_Test_009
253  * @tc.desc: local ledger init test
254  * @tc.type: FUNC
255  * @tc.require:
256  */
257 HWTEST_F(LNNLedgerMockTest, LOCAL_LEDGER_MOCK_Test_009, TestSize.Level1)
258 {
259     LocalLedgerDepsInterfaceMock localLedgerMock;
260     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
261     EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
262     EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
263     EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
264     EXPECT_CALL(localLedgerMock, LnnInitOhosAccount()).WillRepeatedly(Return(SOFTBUS_OK));
265     EXPECT_TRUE(LnnInitLocalLedgerDelay() == SOFTBUS_OK);
266 }
267 
268 /*
269  * @tc.name: Local_Ledger_Key_Test_001
270  * @tc.desc: local ledger key test
271  * @tc.type: FUNC
272  * @tc.require:
273  */
274 HWTEST_F(LNNLedgerMockTest, Local_Ledger_Key_Test_001, TestSize.Level1)
275 {
276     char infoTmp[] = "";
277     char *infoMinsize = infoTmp;
278     char *infoCharNull = nullptr;
279     uint32_t len = 0;
280 
281     LocalLedgerDepsInterfaceMock localLedgerMock;
282     EXPECT_CALL(localLedgerMock, GetCommonDeviceVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
283     EXPECT_CALL(localLedgerMock, GetDeviceSecurityLevel(_)).WillRepeatedly(Return(SOFTBUS_OK));
284     EXPECT_CALL(localLedgerMock, SoftBusGetBtState()).WillRepeatedly(Return(BLE_DISABLE));
285     EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
286     EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
287     EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
288     EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
289     EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
290     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, NotNull(), _))
291         .WillRepeatedly(localLedgerMock.LedgerGetCommonDevInfo);
292     EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
293     EXPECT_CALL(localLedgerMock, SoftBusRegBusCenterVarDump(_, _))
294         .WillRepeatedly(localLedgerMock.LedgerSoftBusRegBusCenterVarDump);
295     int32_t ret = LnnInitLocalLedger();
296     EXPECT_TRUE(ret == SOFTBUS_OK);
297     for (uint32_t i = 0; i < sizeof(g_localKeyTable) / sizeof(LocalLedgerKey); i++) {
298         if (g_localKeyTable[i].getInfo != nullptr) {
299             EXPECT_EQ(g_localKeyTable[i].getInfo((void *)infoCharNull, len), SOFTBUS_INVALID_PARAM);
300         }
301     }
302     EXPECT_EQ(g_localKeyTable[0].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
303     EXPECT_EQ(g_localKeyTable[1].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
304     EXPECT_EQ(g_localKeyTable[2].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
305     EXPECT_EQ(g_localKeyTable[3].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
306     EXPECT_EQ(g_localKeyTable[4].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
307     EXPECT_EQ(g_localKeyTable[5].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
308     EXPECT_EQ(g_localKeyTable[6].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
309     EXPECT_EQ(g_localKeyTable[7].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
310     EXPECT_EQ(g_localKeyTable[8].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
311     EXPECT_EQ(g_localKeyTable[9].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
312     EXPECT_EQ(g_localKeyTable[10].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
313     EXPECT_EQ(g_localKeyTable[11].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
314     EXPECT_EQ(g_localKeyTable[18].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
315     EXPECT_EQ(g_localKeyTable[19].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
316     EXPECT_EQ(g_localKeyTable[35].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
317     LnnDeinitLocalLedger();
318 }
319 
320 /*
321  * @tc.name: Local_Ledger_Key_Test_002
322  * @tc.desc: local ledger key test
323  * @tc.type: FUNC
324  * @tc.require:
325  */
326 HWTEST_F(LNNLedgerMockTest, Local_Ledger_Key_Test_002, TestSize.Level1)
327 {
328     char infoTmp[] = "";
329     char *infoMinsize = infoTmp;
330     uint32_t len = 0;
331     LocalLedgerDepsInterfaceMock localLedgerMock;
332     EXPECT_CALL(localLedgerMock, GetCommonDeviceVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
333     EXPECT_CALL(localLedgerMock, GetDeviceSecurityLevel(_)).WillRepeatedly(Return(SOFTBUS_OK));
334     EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
335     EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
336     EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
337     EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
338     EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
339     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, NotNull(), _))
340         .WillRepeatedly(localLedgerMock.LedgerGetCommonDevInfo);
341     EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
342     EXPECT_CALL(localLedgerMock, SoftBusRegBusCenterVarDump(_, _))
343         .WillRepeatedly(localLedgerMock.LedgerSoftBusRegBusCenterVarDump);
344     int32_t ret = LnnInitLocalLedger();
345     EXPECT_TRUE(ret == SOFTBUS_OK);
346     EXPECT_EQ(g_localKeyTable[12].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
347     EXPECT_EQ(g_localKeyTable[13].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
348     EXPECT_EQ(g_localKeyTable[14].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
349     EXPECT_EQ(g_localKeyTable[15].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
350     EXPECT_EQ(g_localKeyTable[16].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
351     EXPECT_EQ(g_localKeyTable[17].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
352     EXPECT_EQ(g_localKeyTable[20].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
353     EXPECT_EQ(g_localKeyTable[24].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
354     EXPECT_EQ(g_localKeyTable[25].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
355     EXPECT_EQ(g_localKeyTable[26].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
356     EXPECT_EQ(g_localKeyTable[27].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
357     EXPECT_EQ(g_localKeyTable[28].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
358     EXPECT_EQ(g_localKeyTable[29].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
359     EXPECT_EQ(g_localKeyTable[30].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
360     EXPECT_EQ(g_localKeyTable[31].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
361     EXPECT_EQ(g_localKeyTable[32].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
362     EXPECT_EQ(g_localKeyTable[33].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
363     EXPECT_EQ(g_localKeyTable[34].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
364     EXPECT_EQ(g_localKeyTable[35].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
365     EXPECT_EQ(g_localKeyTable[41].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
366     LnnDeinitLocalLedger();
367 }
368 
369 /*
370  * @tc.name: Local_Ledger_Key_Test_003
371  * @tc.desc: local ledger key test
372  * @tc.type: FUNC
373  * @tc.require:
374  */
375 HWTEST_F(LNNLedgerMockTest, Local_Ledger_Key_Test_003, TestSize.Level1)
376 {
377     LocalLedgerDepsInterfaceMock localLedgerMock;
378     EXPECT_CALL(localLedgerMock, GetCommonDeviceVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
379     EXPECT_CALL(localLedgerMock, GetDeviceSecurityLevel(_)).WillRepeatedly(Return(SOFTBUS_OK));
380     EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
381     EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
382     EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
383     EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
384     EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
385     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, NotNull(), _))
386         .WillRepeatedly(localLedgerMock.LedgerGetCommonDevInfo);
387     EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
388     EXPECT_CALL(localLedgerMock, SoftBusRegBusCenterVarDump(_, _))
389         .WillRepeatedly(localLedgerMock.LedgerSoftBusRegBusCenterVarDump);
390     EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
391     for (uint32_t i = 0; i < sizeof(g_localKeyTable) / sizeof(LocalLedgerKey); i++) {
392         if (g_localKeyTable[i].getInfo != nullptr) {
393             EXPECT_EQ(g_localKeyTable[i].getInfo(nullptr, 0), SOFTBUS_INVALID_PARAM);
394         }
395     }
396     LocalLedgerKeyTestPackaged();
397     LnnDeinitLocalLedger();
398 }
399 
400 /*
401  * @tc.name: Local_Ledger_Key_Test_005
402  * @tc.desc: local ledger key test
403  * @tc.type: FUNC
404  * @tc.require:
405  */
406 HWTEST_F(LNNLedgerMockTest, Local_Ledger_Key_Test_005, TestSize.Level1)
407 {
408     NodeInfo *info = nullptr;
409     int32_t ret = LnnInitLocalNodeInfo(info);
410     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
411 
412     NodeInfo *nodeInfo = &g_localNetLedger.localInfo;
413     (void)memset_s(nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
414     nodeInfo->authCapacity |= (1 << (uint32_t)BIT_SUPPORT_BR_DUP_BLE);
415     LocalLedgerDepsInterfaceMock localLedgerMock;
416     EXPECT_CALL(localLedgerMock, GetCommonDeviceVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
417     EXPECT_CALL(localLedgerMock, GetDeviceSecurityLevel(_)).WillRepeatedly(Return(SOFTBUS_OK));
418     EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
419     EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
420     EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
421     EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
422     EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
423     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, NotNull(), _))
424         .WillRepeatedly(localLedgerMock.LedgerGetCommonDevInfoGlass);
425     EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_))
426         .WillOnce(Return(SOFTBUS_OK))
427         .WillRepeatedly(Return(SOFTBUS_SET_P2P_INFO_FAIL));
428     ret = LnnInitLocalNodeInfo(nodeInfo);
429     EXPECT_EQ(ret, SOFTBUS_OK);
430     EXPECT_EQ(nodeInfo->authCapacity, 0);
431     ret = LnnInitLocalNodeInfo(nodeInfo);
432     EXPECT_EQ(ret, SOFTBUS_SET_P2P_INFO_FAIL);
433     ret = LnnInitLocalNodeInfo(nodeInfo);
434     EXPECT_EQ(ret, SOFTBUS_SET_P2P_INFO_FAIL);
435 }
436 
437 /*
438  * @tc.name: Local_Ledger_Key_Test_006
439  * @tc.desc: local ledger key test
440  * @tc.type: FUNC
441  * @tc.require:
442  */
443 HWTEST_F(LNNLedgerMockTest, Local_Ledger_Key_Test_006, TestSize.Level1)
444 {
445     int32_t ret = LnnSetLocalUnifiedName(nullptr);
446     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
447 
448     const char *unifiedName = "testJohn";
449     ret = LnnSetLocalUnifiedName(unifiedName);
450     EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
451 
452     ret = UpdateLocalPubMac(nullptr);
453     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
454 
455     const void *testId = "testId";
456     ret = UpdateLocalPubMac(testId);
457     EXPECT_EQ(ret, SOFTBUS_OK);
458 
459     ret = LlUpdateStaticCapability(nullptr);
460     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
461 
462     ret = LlUpdateStaticCapability(testId);
463     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
464 }
465 
466 /*
467  * @tc.name: Local_Ledger_Key_Test_007
468  * @tc.desc: local ledger key test
469  * @tc.type: FUNC
470  * @tc.require:
471  */
472 HWTEST_F(LNNLedgerMockTest, Local_Ledger_Key_Test_007, TestSize.Level1)
473 {
474     uint32_t len = 101;
475     int32_t ret = LlGetStaticCapability(nullptr, 1);
476     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
477     ret = LlGetIrk(nullptr, len);
478     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
479     ret = LlGetPubMac(nullptr, len);
480     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
481     ret = LlGetCipherInfoKey(nullptr, len);
482     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
483 
484     void *buf = SoftBusCalloc(100);
485     ASSERT_TRUE(buf != nullptr);
486     ret = LlGetStaticCapability(buf, len);
487     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
488     ret = LlGetIrk(buf, 0);
489     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
490     ret = LlGetPubMac(buf, 0);
491     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
492     ret = LlGetCipherInfoKey(buf, 0);
493     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
494 
495     ret = LlGetStaticCapability(buf, 100);
496     EXPECT_EQ(ret, SOFTBUS_OK);
497     ret = LlGetIrk(buf, len);
498     EXPECT_EQ(ret, SOFTBUS_OK);
499     ret = LlGetPubMac(buf, len);
500     EXPECT_EQ(ret, SOFTBUS_OK);
501     ret = LlGetCipherInfoKey(buf, 0);
502     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
503     SoftBusFree(buf);
504 }
505 
506 /*
507  * @tc.name: Local_Ledger_Key_Test_008
508  * @tc.desc: local ledger key test
509  * @tc.type: FUNC
510  * @tc.require:
511  */
512 HWTEST_F(LNNLedgerMockTest, Local_Ledger_Key_Test_008, TestSize.Level1)
513 {
514     LocalLedgerDepsInterfaceMock localLedgerMock;
515     EXPECT_CALL(localLedgerMock, GetCommonDeviceVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
516     EXPECT_CALL(localLedgerMock, GetDeviceSecurityLevel(_)).WillRepeatedly(Return(SOFTBUS_OK));
517     EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
518     EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
519     EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
520     EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
521     EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
522     EXPECT_CALL(localLedgerMock, SoftBusRegBusCenterVarDump(_, _))
523         .WillRepeatedly(localLedgerMock.LedgerSoftBusRegBusCenterVarDump);
524     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, NotNull(), _))
525         .WillRepeatedly(localLedgerMock.LedgerGetCommonDevInfo);
526     EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_))
527         .WillOnce(Return(SOFTBUS_OK))
528         .WillRepeatedly(Return(SOFTBUS_SET_P2P_INFO_FAIL));
529     EXPECT_EQ(LnnInitLocalLedger(), SOFTBUS_OK);
530     EXPECT_EQ(LnnUpdateLocalScreenStatus(true), SOFTBUS_OK);
531     EXPECT_EQ(LnnUpdateLocalScreenStatus(false), SOFTBUS_OK);
532     LnnDeinitLocalLedger();
533 }
534 
535 /*
536  * @tc.name: UPDATE_STATE_VERSION_Test_001
537  * @tc.desc: UpdateStateVersion test
538  * @tc.type: FUNC
539  * @tc.require:
540  */
541 HWTEST_F(LNNLedgerMockTest, UPDATE_STATE_VERSION_Test_001, TestSize.Level1)
542 {
543     LocalLedgerDepsInterfaceMock localLedgerMock;
544     EXPECT_CALL(localLedgerMock, GetCommonDeviceVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
545     EXPECT_CALL(localLedgerMock, GetDeviceSecurityLevel(_)).WillRepeatedly(Return(SOFTBUS_OK));
546     EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
547     EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
548     EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
549     EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
550     EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
551     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, NotNull(), _))
552         .WillRepeatedly(localLedgerMock.LedgerGetCommonDevInfo);
553     EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
554     EXPECT_CALL(localLedgerMock, SoftBusRegBusCenterVarDump(_, _))
555         .WillRepeatedly(localLedgerMock.LedgerSoftBusRegBusCenterVarDump);
556     EXPECT_EQ(LnnInitLocalLedger(), SOFTBUS_OK);
557     EXPECT_EQ(UpdateStateVersion(nullptr), SOFTBUS_INVALID_PARAM);
558     int32_t version = 100;
559     EXPECT_EQ(UpdateStateVersion(reinterpret_cast<const void *>(&version)), SOFTBUS_OK);
560 }
561 
562 /*
563  * @tc.name: L1_GET_CONN_SUB_FEATURE_CAPA_Test_001
564  * @tc.desc: L1GetConnSubFeatureCapa test
565  * @tc.type: FUNC
566  * @tc.require:
567  */
568 HWTEST_F(LNNLedgerMockTest, L1_GET_CONN_SUB_FEATURE_CAPA_Test_001, TestSize.Level1)
569 {
570     uint64_t feature = 100;
571     uint32_t len = sizeof(uint64_t) + 1;
572     EXPECT_EQ(L1GetConnSubFeatureCapa(nullptr, len), SOFTBUS_INVALID_PARAM);
573     EXPECT_EQ(L1GetConnSubFeatureCapa(reinterpret_cast<void *>(&feature), len), SOFTBUS_INVALID_PARAM);
574     len = sizeof(uint64_t);
575     EXPECT_EQ(L1GetConnSubFeatureCapa(reinterpret_cast<void *>(&feature), len), SOFTBUS_OK);
576 }
577 
578 /*
579  * @tc.name: L1_GET_WIFI_CFG_Test_001
580  * @tc.desc: L1GetWifiCfg test
581  * @tc.type: FUNC
582  * @tc.require:
583  */
584 HWTEST_F(LNNLedgerMockTest, L1_GET_WIFI_CFG_Test_001, TestSize.Level1)
585 {
586     const char *wifiCfg = "wifiCfgTest";
587     uint32_t len = WIFI_CFG_INFO_MAX_LEN - 1;
588     EXPECT_EQ(L1GetWifiCfg(nullptr, len), SOFTBUS_INVALID_PARAM);
589     EXPECT_EQ(L1GetWifiCfg(reinterpret_cast<void *>(const_cast<char *>(wifiCfg)), len), SOFTBUS_INVALID_PARAM);
590 }
591 
592 /*
593  * @tc.name: L1_GET_CHAN_LIST_5G_Test_001
594  * @tc.desc: L1GetChanList5g test
595  * @tc.type: FUNC
596  * @tc.require:
597  */
598 HWTEST_F(LNNLedgerMockTest, L1_GET_CHAN_LIST_5G_Test_001, TestSize.Level1)
599 {
600     char *chanList5g = (char *)SoftBusCalloc(WIFI_CFG_INFO_MAX_LEN);
601     if (chanList5g == nullptr) {
602         return;
603     }
604     uint32_t len = WIFI_CFG_INFO_MAX_LEN - 1;
605     EXPECT_EQ(L1GetChanList5g(nullptr, len), SOFTBUS_INVALID_PARAM);
606     EXPECT_EQ(L1GetChanList5g(reinterpret_cast<void *>(chanList5g), len), SOFTBUS_INVALID_PARAM);
607     len = WIFI_CFG_INFO_MAX_LEN;
608     EXPECT_EQ(L1GetChanList5g(reinterpret_cast<void *>(chanList5g), len), SOFTBUS_OK);
609     SoftBusFree(chanList5g);
610 }
611 
612 /*
613  * @tc.name: L1_GET_STA_FREQUENCY_Test_001
614  * @tc.desc: L1GetStaFrequency test
615  * @tc.type: FUNC
616  * @tc.require:
617  */
618 HWTEST_F(LNNLedgerMockTest, L1_GET_STA_FREQUENCY_Test_001, TestSize.Level1)
619 {
620     int32_t frequency = 0;
621     uint32_t len = LNN_COMMON_LEN - 1;
622     EXPECT_EQ(L1GetStaFrequency(nullptr, len), SOFTBUS_INVALID_PARAM);
623     EXPECT_EQ(L1GetStaFrequency(reinterpret_cast<void *>(&frequency), len), SOFTBUS_INVALID_PARAM);
624     len = LNN_COMMON_LEN;
625     EXPECT_EQ(L1GetStaFrequency(reinterpret_cast<void *>(&frequency), len), SOFTBUS_OK);
626 }
627 
628 /*
629  * @tc.name: L1_GET_NODE_DATA_CHANGE_FLAG_Test_001
630  * @tc.desc: L1GetNodeDataChangeFlag test
631  * @tc.type: FUNC
632  * @tc.require:
633  */
634 HWTEST_F(LNNLedgerMockTest, L1_GET_NODE_DATA_CHANGE_FLAG_Test_001, TestSize.Level1)
635 {
636     int16_t flag = 0;
637     uint32_t len = DATA_CHANGE_FLAG_BUF_LEN - 1;
638     EXPECT_EQ(L1GetNodeDataChangeFlag(nullptr, len), SOFTBUS_INVALID_PARAM);
639     EXPECT_EQ(L1GetNodeDataChangeFlag(reinterpret_cast<void *>(&flag), len), SOFTBUS_INVALID_PARAM);
640     len = DATA_CHANGE_FLAG_BUF_LEN;
641     EXPECT_EQ(L1GetNodeDataChangeFlag(reinterpret_cast<void *>(&flag), len), SOFTBUS_OK);
642 }
643 
644 /*
645  * @tc.name: L1_GET_DATA_DYNAMIC_LEVEL_Test_001
646  * @tc.desc: L1GetDataDynamicLevel test
647  * @tc.type: FUNC
648  * @tc.require:
649  */
650 HWTEST_F(LNNLedgerMockTest, L1_GET_DATA_DYNAMIC_LEVEL_Test_001, TestSize.Level1)
651 {
652     uint16_t level = 0;
653     uint32_t len = DATA_DYNAMIC_LEVEL_BUF_LEN - 1;
654     EXPECT_EQ(L1GetDataDynamicLevel(nullptr, len), SOFTBUS_INVALID_PARAM);
655     EXPECT_EQ(L1GetDataDynamicLevel(reinterpret_cast<void *>(&level), len), SOFTBUS_INVALID_PARAM);
656     len = DATA_DYNAMIC_LEVEL_BUF_LEN;
657     EXPECT_EQ(L1GetDataDynamicLevel(reinterpret_cast<void *>(&level), len), SOFTBUS_OK);
658     EXPECT_EQ(UpdateDataDynamicLevel(nullptr), SOFTBUS_INVALID_PARAM);
659 }
660 
661 /*
662  * @tc.name: L1_GET_DATA_STATIC_LEVEL_Test_001
663  * @tc.desc: L1GetDataStaticLevel test
664  * @tc.type: FUNC
665  * @tc.require:
666  */
667 HWTEST_F(LNNLedgerMockTest, L1_GET_DATA_STATIC_LEVEL_Test_001, TestSize.Level1)
668 {
669     uint16_t level = 0;
670     uint32_t len = DATA_STATIC_LEVEL_BUF_LEN - 1;
671     EXPECT_EQ(L1GetDataStaticLevel(nullptr, len), SOFTBUS_INVALID_PARAM);
672     EXPECT_EQ(L1GetDataStaticLevel(reinterpret_cast<void *>(&level), len), SOFTBUS_INVALID_PARAM);
673     len = DATA_STATIC_LEVEL_BUF_LEN;
674     EXPECT_EQ(L1GetDataStaticLevel(reinterpret_cast<void *>(&level), len), SOFTBUS_OK);
675     EXPECT_EQ(UpdateDataStaticLevel(nullptr), SOFTBUS_INVALID_PARAM);
676     EXPECT_EQ(UpdateDataSwitchLevel(nullptr), SOFTBUS_INVALID_PARAM);
677 }
678 
679 /*
680  * @tc.name: L1_GET_DATA_SWITCH_LENGTH_Test_001
681  * @tc.desc: L1GetDataSwitchLength test
682  * @tc.type: FUNC
683  * @tc.require:
684  */
685 HWTEST_F(LNNLedgerMockTest, L1_GET_DATA_SWITCH_LENGTH_Test_001, TestSize.Level1)
686 {
687     uint16_t length = 0;
688     uint32_t len = DATA_SWITCH_LENGTH_BUF_LEN - 1;
689     EXPECT_EQ(L1GetDataSwitchLength(nullptr, len), SOFTBUS_INVALID_PARAM);
690     EXPECT_EQ(L1GetDataSwitchLength(reinterpret_cast<void *>(&length), len), SOFTBUS_INVALID_PARAM);
691     len = DATA_SWITCH_LENGTH_BUF_LEN;
692     EXPECT_EQ(L1GetDataSwitchLength(reinterpret_cast<void *>(&length), len), SOFTBUS_OK);
693     EXPECT_EQ(UpdateDataSwitchLength(nullptr), SOFTBUS_INVALID_PARAM);
694 }
695 
696 /*
697  * @tc.name: LOCAL_GET_NODE_BLE_START_TIME_Test_001
698  * @tc.desc: LocalGetNodeBleStartTime test
699  * @tc.type: FUNC
700  * @tc.require:
701  */
702 HWTEST_F(LNNLedgerMockTest, LOCAL_GET_NODE_BLE_START_TIME_Test_001, TestSize.Level1)
703 {
704     int64_t timeStamp = 0;
705     uint32_t len = sizeof(int64_t) - 1;
706     EXPECT_EQ(LocalGetNodeBleStartTime(nullptr, len), SOFTBUS_INVALID_PARAM);
707     EXPECT_EQ(LocalGetNodeBleStartTime(reinterpret_cast<void *>(&timeStamp), len), SOFTBUS_INVALID_PARAM);
708     len = sizeof(int64_t);
709     EXPECT_EQ(LocalGetNodeBleStartTime(reinterpret_cast<void *>(&timeStamp), len), SOFTBUS_OK);
710 }
711 
712 /*
713  * @tc.name: LOCAL_GET_NETWORK_ID_TIME_STAMP_Test_001
714  * @tc.desc: LocalGetNetworkIdTimeStamp test
715  * @tc.type: FUNC
716  * @tc.require:
717  */
718 HWTEST_F(LNNLedgerMockTest, LOCAL_GET_NETWORK_ID_TIME_STAMP_Test_001, TestSize.Level1)
719 {
720     int64_t timeStamp = 0;
721     uint32_t len = sizeof(int64_t) - 1;
722     EXPECT_EQ(LocalGetNetworkIdTimeStamp(nullptr, len), SOFTBUS_INVALID_PARAM);
723     EXPECT_EQ(LocalGetNetworkIdTimeStamp(reinterpret_cast<void *>(&timeStamp), len), SOFTBUS_INVALID_PARAM);
724     len = sizeof(int64_t);
725     EXPECT_EQ(LocalGetNetworkIdTimeStamp(reinterpret_cast<void *>(&timeStamp), len), SOFTBUS_OK);
726     EXPECT_EQ(InitLocalVersionType(nullptr), SOFTBUS_INVALID_PARAM);
727     EXPECT_EQ(InitConnectInfo(nullptr), SOFTBUS_INVALID_PARAM);
728 }
729 
730 /*
731  * @tc.name: UPDATE_UNIFIED_NAME_Test_001
732  * @tc.desc: UpdateUnifiedName test
733  * @tc.type: FUNC
734  * @tc.require:
735  */
736 HWTEST_F(LNNLedgerMockTest, UPDATE_UNIFIED_NAME_Test_001, TestSize.Level1)
737 {
738     LocalLedgerDepsInterfaceMock localLedgerMock;
739     EXPECT_CALL(localLedgerMock, LnnGetLocalDevInfoPacked).WillRepeatedly(Return(SOFTBUS_OK));
740     const char *unifiedName = "unifiedNameTest";
741     EXPECT_EQ(UpdateUnifiedName(nullptr), SOFTBUS_INVALID_PARAM);
742     EXPECT_EQ(UpdateUnifiedName(reinterpret_cast<const void *>(const_cast<char *>(unifiedName))), SOFTBUS_OK);
743 }
744 
745 /*
746  * @tc.name: UPDATE_UNIFIED_DEFAULT_NAME_Test_001
747  * @tc.desc: UpdateUnifiedDefaultName test
748  * @tc.type: FUNC
749  * @tc.require:
750  */
751 HWTEST_F(LNNLedgerMockTest, UPDATE_UNIFIED_DEFAULT_NAME_Test_001, TestSize.Level1)
752 {
753     LocalLedgerDepsInterfaceMock localLedgerMock;
754     EXPECT_CALL(localLedgerMock, LnnGetLocalDevInfoPacked).WillRepeatedly(Return(SOFTBUS_OK));
755     const char *unifiedDefaultName = "unifiedDefaultNameTest";
756     EXPECT_EQ(UpdateUnifiedDefaultName(nullptr), SOFTBUS_INVALID_PARAM);
757     EXPECT_EQ(UpdateUnifiedDefaultName(reinterpret_cast<const void *>(const_cast<char *>(unifiedDefaultName))),
758         SOFTBUS_OK);
759 }
760 
761 /*
762  * @tc.name: UPDATE_NICK_NAME_Test_001
763  * @tc.desc: UpdateNickName test
764  * @tc.type: FUNC
765  * @tc.require:
766  */
767 HWTEST_F(LNNLedgerMockTest, UPDATE_NICK_NAME_Test_001, TestSize.Level1)
768 {
769     LocalLedgerDepsInterfaceMock localLedgerMock;
770     EXPECT_CALL(localLedgerMock, LnnGetLocalDevInfoPacked).WillRepeatedly(Return(SOFTBUS_OK));
771     const char *nickName = "nickNameTest";
772     EXPECT_EQ(UpdateNickName(nullptr), SOFTBUS_INVALID_PARAM);
773     EXPECT_EQ(UpdateNickName(reinterpret_cast<const void *>(const_cast<char *>(nickName))), SOFTBUS_OK);
774 }
775 
776 /*
777  * @tc.name: UPDATEL_1OCAL_CONN_SUB_FEATURE_CAPABILITY_Test_001
778  * @tc.desc: UpdateLocalConnSubFeatureCapability test
779  * @tc.type: FUNC
780  * @tc.require:
781  */
782 HWTEST_F(LNNLedgerMockTest, UPDATEL_1OCAL_CONN_SUB_FEATURE_CAPABILITY_Test_001, TestSize.Level1)
783 {
784     int32_t capability = 0;
785     EXPECT_EQ(UpdateLocalConnSubFeatureCapability(nullptr), SOFTBUS_INVALID_PARAM);
786     EXPECT_EQ(UpdateLocalConnSubFeatureCapability(reinterpret_cast<const void *>(&capability)), SOFTBUS_OK);
787 }
788 
789 /*
790  * @tc.name: UPDATE_MASGER_NODE_WEIGHT_Test_001
791  * @tc.desc: UpdateMasgerNodeWeight test
792  * @tc.type: FUNC
793  * @tc.require:
794  */
795 HWTEST_F(LNNLedgerMockTest, UPDATE_MASGER_NODE_WEIGHT_Test_001, TestSize.Level1)
796 {
797     int32_t weight = 100;
798     EXPECT_EQ(UpdateMasgerNodeWeight(nullptr), SOFTBUS_INVALID_PARAM);
799     EXPECT_EQ(UpdateMasgerNodeWeight(reinterpret_cast<const void *>(&weight)), SOFTBUS_OK);
800 }
801 
802 /*
803  * @tc.name: UPDATE_P2P_ROLE_Test_001
804  * @tc.desc: UpdateP2pRole test
805  * @tc.type: FUNC
806  * @tc.require:
807  */
808 HWTEST_F(LNNLedgerMockTest, UPDATE_P2P_ROLE_Test_001, TestSize.Level1)
809 {
810     int32_t role = 1;
811     EXPECT_EQ(UpdateP2pRole(nullptr), SOFTBUS_INVALID_PARAM);
812     EXPECT_EQ(UpdateP2pRole(reinterpret_cast<const void *>(&role)), SOFTBUS_OK);
813 }
814 
815 /*
816  * @tc.name: UPDATE_STA_FREQUENCY_Test_001
817  * @tc.desc: UpdateStaFrequency test
818  * @tc.type: FUNC
819  * @tc.require:
820  */
821 HWTEST_F(LNNLedgerMockTest, UPDATE_STA_FREQUENCY_Test_001, TestSize.Level1)
822 {
823     int32_t staFrequency = 1;
824     EXPECT_EQ(UpdateStaFrequency(nullptr), SOFTBUS_INVALID_PARAM);
825     EXPECT_EQ(UpdateStaFrequency(reinterpret_cast<const void *>(&staFrequency)), SOFTBUS_OK);
826     EXPECT_EQ(LnnUpdateLocalDeviceName(nullptr), SOFTBUS_INVALID_PARAM);
827 }
828 
829 /*
830  * @tc.name: LL_GET_DEVICE_SECURITY_LEVEL_Test_001
831  * @tc.desc: LlGetDeviceSecurityLevel test
832  * @tc.type: FUNC
833  * @tc.require:
834  */
835 HWTEST_F(LNNLedgerMockTest, LL_GET_DEVICE_SECURITY_LEVEL_Test_001, TestSize.Level1)
836 {
837     int32_t level = 1;
838     uint32_t len = sizeof(int32_t) - 1;
839     EXPECT_EQ(LlGetDeviceSecurityLevel(nullptr, len), SOFTBUS_INVALID_PARAM);
840     EXPECT_EQ(LlGetDeviceSecurityLevel(reinterpret_cast<void *>(&level), len), SOFTBUS_INVALID_PARAM);
841     len = sizeof(int32_t);
842     EXPECT_EQ(LlGetDeviceSecurityLevel(reinterpret_cast<void *>(&level), len), SOFTBUS_OK);
843 }
844 
845 /*
846  * @tc.name: LL_UPDATE_DEVICE_SECURITY_LEVEL_Test_001
847  * @tc.desc: LlUpdateDeviceSecurityLevel test
848  * @tc.type: FUNC
849  * @tc.require:
850  */
851 HWTEST_F(LNNLedgerMockTest, LL_UPDATE_DEVICE_SECURITY_LEVEL_Test_001, TestSize.Level1)
852 {
853     int32_t level = 1;
854     EXPECT_EQ(LlUpdateDeviceSecurityLevel(nullptr), SOFTBUS_INVALID_PARAM);
855     EXPECT_EQ(LlUpdateDeviceSecurityLevel(reinterpret_cast<const void *>(&level)), SOFTBUS_OK);
856 }
857 
858 /*
859  * @tc.name: LL_GET_USER_ID_CHECK_SUM_Test_001
860  * @tc.desc: LlGetUserIdCheckSum test
861  * @tc.type: FUNC
862  * @tc.require:
863  */
864 HWTEST_F(LNNLedgerMockTest, LL_GET_USER_ID_CHECK_SUM_Test_001, TestSize.Level1)
865 {
866     int32_t checkSum = 0;
867     uint32_t len = USERID_CHECKSUM_LEN + 1;
868     EXPECT_EQ(LlGetUserIdCheckSum(nullptr, len), SOFTBUS_INVALID_PARAM);
869     EXPECT_EQ(LlGetUserIdCheckSum(reinterpret_cast<void *>(&checkSum), len), SOFTBUS_INVALID_PARAM);
870     len = USERID_CHECKSUM_LEN;
871     EXPECT_EQ(LlGetUserIdCheckSum(reinterpret_cast<void *>(&checkSum), len), SOFTBUS_OK);
872 }
873 
874 /*
875  * @tc.name: LL_GET_P2P_IP_Test_001
876  * @tc.desc: LlGetP2pIp test
877  * @tc.type: FUNC
878  * @tc.require:
879  */
880 HWTEST_F(LNNLedgerMockTest, LL_GET_P2P_IP_Test_001, TestSize.Level1)
881 {
882     char *p2pIp = (char *)SoftBusCalloc(IP_LEN);
883     if (p2pIp == nullptr) {
884         return;
885     }
886     uint32_t len = IP_LEN;
887     EXPECT_EQ(LlGetP2pIp(nullptr, len), SOFTBUS_INVALID_PARAM);
888     EXPECT_EQ(LlGetP2pIp(reinterpret_cast<void *>(p2pIp), len), SOFTBUS_OK);
889     EXPECT_EQ(UpdateLocalIrk(nullptr), SOFTBUS_INVALID_PARAM);
890     SoftBusFree(p2pIp);
891 }
892 
893 /*
894  * @tc.name: LL_UPDATE_LOCAL_P2P_IP_Test_001
895  * @tc.desc: LlUpdateLocalP2pIp test
896  * @tc.type: FUNC
897  * @tc.require:
898  */
899 HWTEST_F(LNNLedgerMockTest, LL_UPDATE_LOCAL_P2P_IP_Test_001, TestSize.Level1)
900 {
901     const char *p2pIp = "127.0.0.0";
902     EXPECT_EQ(LlUpdateLocalP2pIp(nullptr), SOFTBUS_INVALID_PARAM);
903     EXPECT_EQ(LlUpdateLocalP2pIp(reinterpret_cast<const void *>(const_cast<char *>(p2pIp))), SOFTBUS_OK);
904 }
905 
906 /*
907  * @tc.name: L1_GET_USER_ID_Test_001
908  * @tc.desc: L1GetUserId test
909  * @tc.type: FUNC
910  * @tc.require:
911  */
912 HWTEST_F(LNNLedgerMockTest, L1_GET_USER_ID_Test_001, TestSize.Level1)
913 {
914     LocalLedgerDepsInterfaceMock localLedgerMock;
915     int32_t userId = 0;
916     uint32_t len = sizeof(int32_t) - 1;
917     EXPECT_EQ(L1GetUserId(nullptr, len), SOFTBUS_INVALID_PARAM);
918     EXPECT_EQ(L1GetUserId(reinterpret_cast<void *>(&userId), len), SOFTBUS_INVALID_PARAM);
919     len = sizeof(int32_t);
920     EXPECT_EQ(L1GetUserId(reinterpret_cast<void *>(&userId), len), SOFTBUS_OK);
921     LnnDeinitLocalLedger();
922 }
923 
924 /*
925  * @tc.name: LL_SLE_CAP_Test_001
926  * @tc.desc: LL_SLE_CAP_Test_001
927  * @tc.type: FUNC
928  * @tc.require:
929  */
930  HWTEST_F(LNNLedgerMockTest, LL_SLE_CAP_Test_001, TestSize.Level1)
931 {
932     int32_t mockSleRangeCap = 1;
933     int32_t sleRangeCapRet = -1;
934     int32_t sleRangeCap = 0;
935     char sleAddrRet[MAC_LEN] = { 0 };
936     LocalLedgerDepsInterfaceMock localLedgerMock;
937     EXPECT_CALL(localLedgerMock, IsSleEnabled()).WillRepeatedly(Return(true));
938     EXPECT_CALL(localLedgerMock, SoftBusAddSleStateListener(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
939     EXPECT_CALL(localLedgerMock, GetSleRangeCapacity()).WillRepeatedly(Return(mockSleRangeCap));
940     EXPECT_CALL(localLedgerMock, GetLocalSleAddr(_, _)).WillRepeatedly(localLedgerMock.MockGetLocalSleAddrFunc);
941     EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
942     EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
943     EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
944     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
945     EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
946     EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
947     EXPECT_CALL(localLedgerMock, GetCommonDeviceVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
948     EXPECT_CALL(localLedgerMock, GetDeviceSecurityLevel(_)).WillRepeatedly(Return(SOFTBUS_OK));
949     EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
950     EXPECT_CALL(localLedgerMock, SoftBusRegBusCenterVarDump(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
951     EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
952     EXPECT_TRUE(LnnGetLocalNumInfo(NUM_KEY_SLE_RANGE_CAP, &sleRangeCapRet) == SOFTBUS_OK);
953     EXPECT_EQ(sleRangeCapRet, sleRangeCap);
954     EXPECT_TRUE(LnnGetLocalStrInfo(STRING_KEY_SLE_ADDR, sleAddrRet, MAC_LEN) == SOFTBUS_OK);
955     EXPECT_NE(sleAddrRet, nullptr);
956     LnnDeinitLocalLedger();
957 }
958 
959 /*
960  * @tc.name: L1_GET_HUKS_KEY_TIME_Test_001
961  * @tc.desc: L1 get huks key time test
962  * @tc.type: FUNC
963  * @tc.require:
964  */
965 HWTEST_F(LNNLedgerMockTest, L1_GET_HUKS_KEY_TIME_Test_001, TestSize.Level1)
966 {
967     int64_t hukTime = 0;
968     uint32_t len = sizeof(uint64_t);
969     EXPECT_EQ(L1GetHuksKeyTime(nullptr, len), SOFTBUS_INVALID_PARAM);
970     EXPECT_EQ(L1GetHuksKeyTime(reinterpret_cast<void *>(&hukTime), len), SOFTBUS_OK);
971 }
972 
973 /*
974  * @tc.name: HANDLE_DEVICE_INFOIF_UDID_CHANGED_001
975  * @tc.desc: HandleDeviceInfoIfUdidChanged test
976  * @tc.type: FUNC
977  * @tc.require:
978  */
979 HWTEST_F(LNNLedgerMockTest, HANDLE_DEVICE_INFOIF_UDID_CHANGED_001, TestSize.Level1)
980 {
981     LocalLedgerDepsInterfaceMock localLedgerMock;
982     EXPECT_CALL(localLedgerMock, GetCommonDevInfo).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
983     int32_t ret = HandleDeviceInfoIfUdidChanged();
984     EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR);
985     NodeInfo localNodeInfo;
986     (void)memset_s(&localNodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
987     localNodeInfo.deviceInfo.deviceUdid[0] = 4;
988     EXPECT_CALL(localLedgerMock, LnnGetLocalDevInfoPacked)
989         .WillRepeatedly(DoAll(SetArgPointee<0>(localNodeInfo), Return(SOFTBUS_OK)));
990     EXPECT_CALL(localLedgerMock, GetCommonDevInfo).WillRepeatedly(Return(SOFTBUS_OK));
991     EXPECT_CALL(localLedgerMock, LnnRemoveStorageConfigPath)
992         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
993         .WillRepeatedly(Return(SOFTBUS_OK));
994     ret = HandleDeviceInfoIfUdidChanged();
995     EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
996     EXPECT_CALL(localLedgerMock, InitTrustedDevInfoTable)
997         .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
998     ret = HandleDeviceInfoIfUdidChanged();
999     EXPECT_EQ(ret, SOFTBUS_NETWORK_INVALID_DEV_INFO);
1000 }
1001 
1002 /*
1003  * @tc.name: HANDLE_DEVICE_INFOIF_UDID_CHANGED_002
1004  * @tc.desc: HandleDeviceInfoIfUdidChanged test
1005  * @tc.type: FUNC
1006  * @tc.require:
1007  */
1008 HWTEST_F(LNNLedgerMockTest, HANDLE_DEVICE_INFOIF_UDID_CHANGED_002, TestSize.Level1)
1009 {
1010     LocalLedgerDepsInterfaceMock localLedgerMock;
1011     NodeInfo localNodeInfo;
1012     (void)memset_s(&localNodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1013     localNodeInfo.deviceInfo.deviceUdid[0] = 4;
1014     EXPECT_CALL(localLedgerMock, LnnGetLocalDevInfoPacked)
1015         .WillRepeatedly(DoAll(SetArgPointee<0>(localNodeInfo), Return(SOFTBUS_OK)));
1016     EXPECT_CALL(localLedgerMock, GetCommonDevInfo).WillRepeatedly(Return(SOFTBUS_OK));
1017     EXPECT_CALL(localLedgerMock, LnnRemoveStorageConfigPath).WillRepeatedly(Return(SOFTBUS_OK));
1018     EXPECT_CALL(localLedgerMock, InitTrustedDevInfoTable).WillRepeatedly(Return(SOFTBUS_OK));
1019     int32_t ret = HandleDeviceInfoIfUdidChanged();
1020     EXPECT_EQ(ret, SOFTBUS_NETWORK_INVALID_DEV_INFO);
1021 }
1022 
1023 /*
1024  * @tc.name: LNN_INIT_LOCAL_NODE_INFO_001
1025  * @tc.desc: LnnInitLocalNodeInfo test
1026  * @tc.type: FUNC
1027  * @tc.require:
1028  */
1029 HWTEST_F(LNNLedgerMockTest, LNN_INIT_LOCAL_NODE_INFO_001, TestSize.Level1)
1030 {
1031     LocalLedgerDepsInterfaceMock localLedgerMock;
1032     NodeInfo nodeInfo;
1033     (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1034     nodeInfo.deviceInfo.deviceTypeId = TYPE_WATCH_ID;
1035     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(Eq(COMM_DEVICE_KEY_BLE_MAC), _, _))
1036         .WillRepeatedly(Return(SOFTBUS_OK));
1037     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(Eq(COMM_DEVICE_KEY_DEVNAME), _, _))
1038         .WillRepeatedly(Return(SOFTBUS_OK));
1039     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(Eq(COMM_DEVICE_KEY_DEVTYPE), _, _))
1040         .WillRepeatedly(Return(SOFTBUS_OK));
1041     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(Eq(COMM_DEVICE_KEY_VERSION_TYPE), _, _))
1042         .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
1043     int32_t ret = LnnInitLocalNodeInfo(&nodeInfo);
1044     EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR);
1045     EXPECT_CALL(localLedgerMock, GetDeviceSecurityLevel)
1046         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
1047         .WillRepeatedly(Return(SOFTBUS_OK));
1048     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(Eq(COMM_DEVICE_KEY_VERSION_TYPE), _, _))
1049         .WillRepeatedly(Return(SOFTBUS_OK));
1050     EXPECT_CALL(localLedgerMock, GetCommonDevInfo(Eq(COMM_DEVICE_KEY_BT_MAC), _, _))
1051         .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
1052     ret = LnnInitLocalNodeInfo(&nodeInfo);
1053     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1054 }
1055 
1056 /*
1057  * @tc.name: LNN_GET_LOCAL_HUM_U16_INFO_001
1058  * @tc.desc: LnnGetLocalNumU16Info test
1059  * @tc.type: FUNC
1060  * @tc.require:
1061  */
1062 HWTEST_F(LNNLedgerMockTest, LNN_GET_LOCAL_HUM_U16_INFO_001, TestSize.Level1)
1063 {
1064     int32_t ret = LnnGetLocalNumU16Info(NUM_KEY_DATA_SWITCH_LENGTH, NULL);
1065     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1066     uint16_t info = 0;
1067     ret = LnnGetLocalNumU16Info(NUM_KEY_DATA_SWITCH_LENGTH, &info);
1068     EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
1069 }
1070 
1071 /*
1072  * @tc.name: LNN_GEN_BROAD_CAST_CIPHER_INFO_001
1073  * @tc.desc: LnnGenBroadcastCipherInfo test
1074  * @tc.type: FUNC
1075  * @tc.require:
1076  */
1077 HWTEST_F(LNNLedgerMockTest, LNN_GEN_BROAD_CAST_CIPHER_INFO_001, TestSize.Level1)
1078 {
1079     LocalLedgerDepsInterfaceMock localLedgerMock;
1080     EXPECT_CALL(localLedgerMock, LnnLoadLocalBroadcastCipherKeyPacked)
1081         .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
1082     int32_t ret = LnnGenBroadcastCipherInfo();
1083     EXPECT_EQ(ret, SOFTBUS_NETWORK_GENERATE_CIPHER_INFO_FAILED);
1084 }
1085 
1086 /*
1087  * @tc.name: LNN_GEN_BROAD_CAST_CIPHER_INFO_002
1088  * @tc.desc: LnnGenBroadcastCipherInfo test
1089  * @tc.type: FUNC
1090  * @tc.require:
1091  */
1092 HWTEST_F(LNNLedgerMockTest, LNN_GEN_BROAD_CAST_CIPHER_INFO_002, TestSize.Level1)
1093 {
1094     LocalLedgerDepsInterfaceMock localLedgerMock;
1095     EXPECT_CALL(localLedgerMock, LnnLoadLocalBroadcastCipherKeyPacked)
1096         .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
1097     EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, Eq(SESSION_KEY_LENGTH)))
1098         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
1099         .WillRepeatedly(Return(SOFTBUS_OK));
1100     int32_t ret = LnnGenBroadcastCipherInfo();
1101     EXPECT_EQ(ret, SOFTBUS_NETWORK_GENERATE_CIPHER_INFO_FAILED);
1102     EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, Eq(BROADCAST_IV_LEN)))
1103         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
1104         .WillRepeatedly(Return(SOFTBUS_OK));
1105     ret = LnnGenBroadcastCipherInfo();
1106     EXPECT_EQ(ret, SOFTBUS_NETWORK_GENERATE_CIPHER_INFO_FAILED);
1107 }
1108 
1109 /*
1110  * @tc.name: LNN_GEN_BROAD_CAST_CIPHER_INFO_003
1111  * @tc.desc: LnnGenBroadcastCipherInfo test
1112  * @tc.type: FUNC
1113  * @tc.require:
1114  */
1115 HWTEST_F(LNNLedgerMockTest, LNN_GEN_BROAD_CAST_CIPHER_INFO_003, TestSize.Level1)
1116 {
1117     LocalLedgerDepsInterfaceMock localLedgerMock;
1118     EXPECT_CALL(localLedgerMock, LnnLoadLocalBroadcastCipherKeyPacked)
1119         .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
1120     EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray).WillRepeatedly(Return(SOFTBUS_OK));
1121     EXPECT_CALL(localLedgerMock, LnnUpdateLocalBroadcastCipherKeyPacked)
1122         .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
1123     int32_t ret = LnnGenBroadcastCipherInfo();
1124     EXPECT_EQ(ret, SOFTBUS_NETWORK_GENERATE_CIPHER_INFO_FAILED);
1125 }
1126 
1127 } // namespace OHOS
1128