1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <securec.h>
18 #include <cstddef>
19 #include <cstdlib>
20 #include <cstring>
21
22 #include "bus_center_info_key.h"
23 #include "bus_center_manager.h"
24 #include "lnn_local_net_ledger.h"
25 #include "lnn_local_net_ledger.c"
26 #include "lnn_log.h"
27 #include "lnn_node_info.h"
28 #include "lnn_local_ledger_deps_mock.h"
29 #include "softbus_adapter_mem.h"
30 #include "softbus_error_code.h"
31 #include "softbus_common.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 {
48 }
49
TearDownTestCase()50 void LNNLedgerMockTest::TearDownTestCase()
51 {
52 }
53
SetUp()54 void LNNLedgerMockTest::SetUp()
55 {
56 LNN_LOGI(LNN_TEST, "LNNLedgerMockTest start");
57 }
58
TearDown()59 void LNNLedgerMockTest::TearDown()
60 {
61 }
62
LocalLedgerKeyTestPackaged(void)63 static void LocalLedgerKeyTestPackaged(void)
64 {
65 EXPECT_EQ(UpdateLocalDeviceUdid(nullptr), SOFTBUS_INVALID_PARAM);
66 EXPECT_EQ(UpdateLocalNetworkId(nullptr), SOFTBUS_ERR);
67 EXPECT_EQ(UpdateLocalUuid(nullptr), SOFTBUS_INVALID_PARAM);
68 EXPECT_EQ(UpdateLocalDeviceType(nullptr), SOFTBUS_INVALID_PARAM);
69 EXPECT_EQ(UpdateLocalDeviceName(nullptr), SOFTBUS_INVALID_PARAM);
70 EXPECT_EQ(UpdateUnifiedName(nullptr), SOFTBUS_INVALID_PARAM);
71 EXPECT_EQ(UpdateUnifiedDefaultName(nullptr), SOFTBUS_INVALID_PARAM);
72 EXPECT_EQ(UpdateNickName(nullptr), SOFTBUS_INVALID_PARAM);
73 EXPECT_EQ(UpdateLocalBtMac(nullptr), SOFTBUS_INVALID_PARAM);
74 EXPECT_EQ(UpdateLocalDeviceIp(nullptr), SOFTBUS_INVALID_PARAM);
75 EXPECT_EQ(UpdateLocalNetIfName(nullptr), SOFTBUS_INVALID_PARAM);
76 EXPECT_EQ(LlUpdateNodeAddr(nullptr), SOFTBUS_INVALID_PARAM);
77 EXPECT_EQ(UpdateP2pMac(nullptr), SOFTBUS_INVALID_PARAM);
78 EXPECT_EQ(UpdateWifiCfg(nullptr), SOFTBUS_INVALID_PARAM);
79 EXPECT_EQ(UpdateChanList5g(nullptr), SOFTBUS_INVALID_PARAM);
80 EXPECT_EQ(UpdateP2pGoMac(nullptr), SOFTBUS_INVALID_PARAM);
81 EXPECT_EQ(LlUpdateLocalOffLineCode(nullptr), SOFTBUS_INVALID_PARAM);
82 EXPECT_EQ(LlUpdateLocalExtData(nullptr), SOFTBUS_INVALID_PARAM);
83 EXPECT_EQ(UpdateWifiDirectAddr(nullptr), SOFTBUS_INVALID_PARAM);
84 EXPECT_EQ(LlUpdateLocalP2pIp(nullptr), SOFTBUS_INVALID_PARAM);
85 EXPECT_EQ(UpdateLocalSessionPort(nullptr), SOFTBUS_INVALID_PARAM);
86 EXPECT_EQ(UpdateLocalAuthPort(nullptr), SOFTBUS_INVALID_PARAM);
87 EXPECT_EQ(UpdateLocalProxyPort(nullptr), SOFTBUS_INVALID_PARAM);
88 EXPECT_EQ(UpdateLocalNetCapability(nullptr), SOFTBUS_INVALID_PARAM);
89 EXPECT_EQ(UpdateLocalFeatureCapability(nullptr), SOFTBUS_INVALID_PARAM);
90 EXPECT_EQ(UpdateLocalCipherInfoKey(nullptr), SOFTBUS_INVALID_PARAM);
91 EXPECT_EQ(UpdateLocalCipherInfoIv(nullptr), SOFTBUS_INVALID_PARAM);
92 EXPECT_EQ(LlUpdateStaticCapLen(nullptr), SOFTBUS_INVALID_PARAM);
93 EXPECT_EQ(LlUpdateAccount(nullptr), SOFTBUS_INVALID_PARAM);
94 EXPECT_EQ(LlUpdateStaticCapability(nullptr), SOFTBUS_INVALID_PARAM);
95 EXPECT_EQ(LnnUpdateLocalScreenStatus(true), SOFTBUS_OK);
96 }
97
98 /*
99 * @tc.name: LOCAL_LEDGER_MOCK_Test_001
100 * @tc.desc: local ledger init test
101 * @tc.type: FUNC
102 * @tc.require:
103 */
104 HWTEST_F(LNNLedgerMockTest, LOCAL_LEDGER_MOCK_Test_001, TestSize.Level1)
105 {
106 LocalLedgerDepsInterfaceMock localLedgerMock;
107 EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
108 EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_ERR));
109 EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
110 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_ERR);
111 }
112
113 /*
114 * @tc.name: LOCAL_LEDGER_MOCK_Test_002
115 * @tc.desc: local ledger init and deinit test
116 * @tc.type: FUNC
117 * @tc.require:
118 */
119 HWTEST_F(LNNLedgerMockTest, LOCAL_LEDGER_MOCK_Test_002, TestSize.Level1)
120 {
121 NiceMock<LocalLedgerDepsInterfaceMock> localLedgerMock;
122 EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
123 EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
124 EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
125 ON_CALL(localLedgerMock, GetCommonOsType).WillByDefault(Return(SOFTBUS_OK));
126 EXPECT_CALL(localLedgerMock,
127 GetCommonDevInfo(_, NotNull(), _)).WillRepeatedly(localLedgerMock.LedgerGetCommonDevInfo);
128 EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
129 EXPECT_CALL(localLedgerMock,
130 SoftBusRegBusCenterVarDump(_, _)).WillRepeatedly(localLedgerMock.LedgerSoftBusRegBusCenterVarDump);
131 int32_t ret = LnnInitLocalLedger();
132 EXPECT_TRUE(ret == SOFTBUS_OK);
133 ret = LnnInitLocalLedger();
134 EXPECT_TRUE(ret == SOFTBUS_OK);
135 LnnDeinitLocalLedger();
136 }
137
138 /*
139 * @tc.name: LOCAL_LEDGER_MOCK_Test_003
140 * @tc.desc: local ledger delay init test
141 * @tc.type: FUNC
142 * @tc.require:
143 */
144 HWTEST_F(LNNLedgerMockTest, LOCAL_LEDGER_MOCK_Test_003, TestSize.Level1)
145 {
146 LocalLedgerDepsInterfaceMock localLedgerMock;
147 EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_ERR));
148 EXPECT_CALL(localLedgerMock, LnnInitOhosAccount()).WillRepeatedly(Return(SOFTBUS_ERR));
149 EXPECT_TRUE(LnnInitLocalLedgerDelay() == SOFTBUS_ERR);
150 }
151
152 /*
153 * @tc.name: LOCAL_LEDGER_MOCK_Test_004
154 * @tc.desc: local ledger init test
155 * @tc.type: FUNC
156 * @tc.require:
157 */
158 HWTEST_F(LNNLedgerMockTest, LOCAL_LEDGER_MOCK_Test_004, TestSize.Level1)
159 {
160 LocalLedgerDepsInterfaceMock localLedgerMock;
161 EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
162 EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
163 EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
164 EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_ERR));
165 EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
166 EXPECT_CALL(localLedgerMock, SoftBusRegBusCenterVarDump(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
167 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_ERR);
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, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
180 EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
181 EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
182 EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
183 EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
184 EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
185 EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_ERR));
186 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_ERR);
187 }
188
189 /*
190 * @tc.name: LOCAL_LEDGER_MOCK_Test_006
191 * @tc.desc: local ledger init test
192 * @tc.type: FUNC
193 * @tc.require:
194 */
195 HWTEST_F(LNNLedgerMockTest, LOCAL_LEDGER_MOCK_Test_006, TestSize.Level1)
196 {
197 LocalLedgerDepsInterfaceMock localLedgerMock;
198 EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
199 EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
200 EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
201 EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
202 EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
203 EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
204 EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
205 EXPECT_CALL(localLedgerMock, SoftBusRegBusCenterVarDump(_, _)).WillRepeatedly(Return(SOFTBUS_ERR));
206 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_ERR);
207 }
208
209 /*
210 * @tc.name: LOCAL_LEDGER_MOCK_Test_007
211 * @tc.desc: local ledger init test
212 * @tc.type: FUNC
213 * @tc.require:
214 */
215 HWTEST_F(LNNLedgerMockTest, LOCAL_LEDGER_MOCK_Test_007, TestSize.Level1)
216 {
217 LocalLedgerDepsInterfaceMock localLedgerMock;
218 EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
219 EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
220 EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
221 EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
222 EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
223 EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _))
224 .WillOnce(Return(SOFTBUS_OK)).WillRepeatedly(Return(SOFTBUS_ERR));
225 EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
226 EXPECT_CALL(localLedgerMock, SoftBusRegBusCenterVarDump(_, _)).WillRepeatedly(Return(SOFTBUS_ERR));
227 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_ERR);
228 }
229
230 /*
231 * @tc.name: LOCAL_LEDGER_MOCK_Test_008
232 * @tc.desc: local ledger init test
233 * @tc.type: FUNC
234 * @tc.require:
235 */
236 HWTEST_F(LNNLedgerMockTest, LOCAL_LEDGER_MOCK_Test_008, TestSize.Level1)
237 {
238 LocalLedgerDepsInterfaceMock localLedgerMock;
239 EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
240 EXPECT_CALL(localLedgerMock, LnnInitOhosAccount()).WillRepeatedly(Return(SOFTBUS_ERR));
241 EXPECT_TRUE(LnnInitLocalLedgerDelay() == SOFTBUS_ERR);
242 }
243
244 /*
245 * @tc.name: LOCAL_LEDGER_MOCK_Test_009
246 * @tc.desc: local ledger init test
247 * @tc.type: FUNC
248 * @tc.require:
249 */
250 HWTEST_F(LNNLedgerMockTest, LOCAL_LEDGER_MOCK_Test_009, TestSize.Level1)
251 {
252 LocalLedgerDepsInterfaceMock localLedgerMock;
253 EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
254 EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
255 EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
256 EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
257 EXPECT_CALL(localLedgerMock, LnnInitOhosAccount()).WillRepeatedly(Return(SOFTBUS_OK));
258 EXPECT_TRUE(LnnInitLocalLedgerDelay() == SOFTBUS_OK);
259 }
260
261 /*
262 * @tc.name: Local_Ledger_Key_Test_001
263 * @tc.desc: local ledger key test
264 * @tc.type: FUNC
265 * @tc.require:
266 */
267 HWTEST_F(LNNLedgerMockTest, Local_Ledger_Key_Test_001, TestSize.Level1)
268 {
269 char infoTmp[] = "";
270 char *infoMinsize = infoTmp;
271 char *infoCharNull = nullptr;
272 uint32_t len = 0;
273
274 LocalLedgerDepsInterfaceMock localLedgerMock;
275 EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
276 EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
277 EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
278 EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
279 EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
280 EXPECT_CALL(localLedgerMock,
281 GetCommonDevInfo(_, NotNull(), _)).WillRepeatedly(localLedgerMock.LedgerGetCommonDevInfo);
282 EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
283 EXPECT_CALL(localLedgerMock,
284 SoftBusRegBusCenterVarDump(_, _)).WillRepeatedly(localLedgerMock.LedgerSoftBusRegBusCenterVarDump);
285 int32_t ret = LnnInitLocalLedger();
286 EXPECT_TRUE(ret == SOFTBUS_OK);
287 for (uint32_t i = 0; i < sizeof(g_localKeyTable) / sizeof(LocalLedgerKey); i++) {
288 if (g_localKeyTable[i].getInfo != NULL) {
289 EXPECT_EQ(g_localKeyTable[i].getInfo((void *)infoCharNull, len), SOFTBUS_INVALID_PARAM);
290 }
291 }
292 EXPECT_EQ(g_localKeyTable[0].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
293 EXPECT_EQ(g_localKeyTable[1].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
294 EXPECT_EQ(g_localKeyTable[2].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
295 EXPECT_EQ(g_localKeyTable[3].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
296 EXPECT_EQ(g_localKeyTable[4].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
297 EXPECT_EQ(g_localKeyTable[5].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
298 EXPECT_EQ(g_localKeyTable[6].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
299 EXPECT_EQ(g_localKeyTable[7].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
300 EXPECT_EQ(g_localKeyTable[8].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
301 EXPECT_EQ(g_localKeyTable[9].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
302 EXPECT_EQ(g_localKeyTable[10].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
303 EXPECT_EQ(g_localKeyTable[11].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
304 EXPECT_EQ(g_localKeyTable[18].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
305 EXPECT_EQ(g_localKeyTable[19].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
306 EXPECT_EQ(g_localKeyTable[35].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
307 LnnDeinitLocalLedger();
308 }
309
310 /*
311 * @tc.name: Local_Ledger_Key_Test_002
312 * @tc.desc: local ledger key test
313 * @tc.type: FUNC
314 * @tc.require:
315 */
316 HWTEST_F(LNNLedgerMockTest, Local_Ledger_Key_Test_002, TestSize.Level1)
317 {
318 char infoTmp[] = "";
319 char *infoMinsize = infoTmp;
320 uint32_t len = 0;
321 LocalLedgerDepsInterfaceMock localLedgerMock;
322 EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
323 EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
324 EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
325 EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
326 EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
327 EXPECT_CALL(localLedgerMock,
328 GetCommonDevInfo(_, NotNull(), _)).WillRepeatedly(localLedgerMock.LedgerGetCommonDevInfo);
329 EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
330 EXPECT_CALL(localLedgerMock,
331 SoftBusRegBusCenterVarDump(_, _)).WillRepeatedly(localLedgerMock.LedgerSoftBusRegBusCenterVarDump);
332 int32_t ret = LnnInitLocalLedger();
333 EXPECT_TRUE(ret == SOFTBUS_OK);
334 EXPECT_EQ(g_localKeyTable[12].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
335 EXPECT_EQ(g_localKeyTable[13].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
336 EXPECT_EQ(g_localKeyTable[14].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
337 EXPECT_EQ(g_localKeyTable[15].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
338 EXPECT_EQ(g_localKeyTable[16].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
339 EXPECT_EQ(g_localKeyTable[17].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
340 EXPECT_EQ(g_localKeyTable[20].getInfo(infoMinsize, len), SOFTBUS_MEM_ERR);
341 EXPECT_EQ(g_localKeyTable[24].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
342 EXPECT_EQ(g_localKeyTable[25].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
343 EXPECT_EQ(g_localKeyTable[26].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
344 EXPECT_EQ(g_localKeyTable[27].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
345 EXPECT_EQ(g_localKeyTable[28].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
346 EXPECT_EQ(g_localKeyTable[29].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
347 EXPECT_EQ(g_localKeyTable[30].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
348 EXPECT_EQ(g_localKeyTable[31].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
349 EXPECT_EQ(g_localKeyTable[32].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
350 EXPECT_EQ(g_localKeyTable[33].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
351 EXPECT_EQ(g_localKeyTable[34].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
352 EXPECT_EQ(g_localKeyTable[35].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
353 EXPECT_EQ(g_localKeyTable[41].getInfo(infoMinsize, len), SOFTBUS_INVALID_PARAM);
354 LnnDeinitLocalLedger();
355 }
356
357 /*
358 * @tc.name: Local_Ledger_Key_Test_003
359 * @tc.desc: local ledger key test
360 * @tc.type: FUNC
361 * @tc.require:
362 */
363 HWTEST_F(LNNLedgerMockTest, Local_Ledger_Key_Test_003, TestSize.Level1)
364 {
365 LocalLedgerDepsInterfaceMock localLedgerMock;
366 EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
367 EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
368 EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
369 EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
370 EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
371 EXPECT_CALL(localLedgerMock,
372 GetCommonDevInfo(_, NotNull(), _)).WillRepeatedly(localLedgerMock.LedgerGetCommonDevInfo);
373 EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
374 EXPECT_CALL(localLedgerMock,
375 SoftBusRegBusCenterVarDump(_, _)).WillRepeatedly(localLedgerMock.LedgerSoftBusRegBusCenterVarDump);
376 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
377 for (uint32_t i = 0; i < sizeof(g_localKeyTable) / sizeof(LocalLedgerKey); i++) {
378 if (g_localKeyTable[i].getInfo != NULL) {
379 EXPECT_EQ(g_localKeyTable[i].getInfo(nullptr, 0), SOFTBUS_INVALID_PARAM);
380 }
381 }
382 LocalLedgerKeyTestPackaged();
383 LnnDeinitLocalLedger();
384 }
385
386 /*
387 * @tc.name: Local_Ledger_Key_Test_005
388 * @tc.desc: local ledger key test
389 * @tc.type: FUNC
390 * @tc.require:
391 */
392 HWTEST_F(LNNLedgerMockTest, Local_Ledger_Key_Test_005, TestSize.Level1)
393 {
394 NodeInfo *info = nullptr;
395 int32_t ret = LnnInitLocalNodeInfo(info);
396 EXPECT_EQ(ret, SOFTBUS_ERR);
397
398 NodeInfo *nodeInfo = (NodeInfo*)SoftBusMalloc(sizeof(NodeInfo));
399 ASSERT_TRUE(nodeInfo != nullptr);
400 (void)memset_s(nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
401
402 LocalLedgerDepsInterfaceMock localLedgerMock;
403 EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
404 EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
405 EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
406 EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
407 EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
408 EXPECT_CALL(localLedgerMock,
409 GetCommonDevInfo(_, NotNull(), _)).WillRepeatedly(localLedgerMock.LedgerGetCommonDevInfo);
410 EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_))
411 .WillOnce(Return(SOFTBUS_OK))
412 .WillRepeatedly(Return(SOFTBUS_ERR));
413 ret = LnnInitLocalNodeInfo(nodeInfo);
414 EXPECT_EQ(ret, SOFTBUS_OK);
415 ret = LnnInitLocalNodeInfo(nodeInfo);
416 EXPECT_EQ(ret, SOFTBUS_ERR);
417 ret = LnnInitLocalNodeInfo(nodeInfo);
418 EXPECT_EQ(ret, SOFTBUS_ERR);
419 if (nodeInfo != NULL) {
420 SoftBusFree(nodeInfo);
421 }
422 }
423
424 /*
425 * @tc.name: Local_Ledger_Key_Test_006
426 * @tc.desc: local ledger key test
427 * @tc.type: FUNC
428 * @tc.require:
429 */
430 HWTEST_F(LNNLedgerMockTest, Local_Ledger_Key_Test_006, TestSize.Level1)
431 {
432 int32_t ret = LnnSetLocalUnifiedName(NULL);
433 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
434
435 const char *unifiedName = "testJohn";
436 ret = LnnSetLocalUnifiedName(unifiedName);
437 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
438
439 ret = UpdateLocalPubMac(NULL);
440 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
441
442 const void *testId = "testId";
443 ret = UpdateLocalPubMac(testId);
444 EXPECT_EQ(ret, SOFTBUS_OK);
445
446 ret = LlUpdateStaticCapability(NULL);
447 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
448
449 ret = LlUpdateStaticCapability(testId);
450 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
451 }
452
453 /*
454 * @tc.name: Local_Ledger_Key_Test_007
455 * @tc.desc: local ledger key test
456 * @tc.type: FUNC
457 * @tc.require:
458 */
459 HWTEST_F(LNNLedgerMockTest, Local_Ledger_Key_Test_007, TestSize.Level1)
460 {
461 uint32_t len = 101;
462 int32_t ret = LlGetStaticCapability(NULL, 1);
463 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
464 ret = LlGetIrk(NULL, len);
465 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
466 ret = LlGetPubMac(NULL, len);
467 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
468 ret = LlGetCipherInfoKey(NULL, len);
469 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
470
471 void *buf = SoftBusCalloc(100);
472 ASSERT_TRUE(buf != nullptr);
473 ret = LlGetStaticCapability(buf, len);
474 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
475 ret = LlGetIrk(buf, 0);
476 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
477 ret = LlGetPubMac(buf, 0);
478 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
479 ret = LlGetCipherInfoKey(buf, 0);
480 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
481
482 ret = LlGetStaticCapability(buf, 100);
483 EXPECT_EQ(ret, SOFTBUS_OK);
484 ret = LlGetIrk(buf, len);
485 EXPECT_EQ(ret, SOFTBUS_OK);
486 ret = LlGetPubMac(buf, len);
487 EXPECT_EQ(ret, SOFTBUS_OK);
488 ret = LlGetCipherInfoKey(buf, 0);
489 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
490 SoftBusFree(buf);
491 }
492
493 /*
494 * @tc.name: Local_Ledger_Key_Test_008
495 * @tc.desc: local ledger key test
496 * @tc.type: FUNC
497 * @tc.require:
498 */
499 HWTEST_F(LNNLedgerMockTest, Local_Ledger_Key_Test_008, TestSize.Level1)
500 {
501 LocalLedgerDepsInterfaceMock localLedgerMock;
502 EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
503 EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
504 EXPECT_CALL(localLedgerMock, LnnGetFeatureCapabilty()).WillRepeatedly(Return(FEATURE));
505 EXPECT_CALL(localLedgerMock, GetCommonOsType(_)).WillRepeatedly(Return(SOFTBUS_OK));
506 EXPECT_CALL(localLedgerMock, GetCommonOsVersion(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
507 EXPECT_CALL(localLedgerMock,
508 GetCommonDevInfo(_, NotNull(), _)).WillRepeatedly(localLedgerMock.LedgerGetCommonDevInfo);
509 EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_))
510 .WillOnce(Return(SOFTBUS_OK))
511 .WillRepeatedly(Return(SOFTBUS_ERR));
512 EXPECT_EQ(LnnInitLocalLedger(), SOFTBUS_OK);
513 EXPECT_EQ(LnnUpdateLocalScreenStatus(true), SOFTBUS_OK);
514 EXPECT_EQ(LnnUpdateLocalScreenStatus(false), SOFTBUS_OK);
515 LnnDeinitLocalLedger();
516 }
517 } // namespace OHOS
518