• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <cstddef>
17 #include <cstdlib>
18 #include <cstring>
19 #include <gtest/gtest.h>
20 #include <securec.h>
21 
22 #include "lnn_data_cloud_sync.c"
23 #include "lnn_data_cloud_sync.h"
24 #include "lnn_data_cloud_sync_deps_mock.h"
25 #include "lnn_kv_adapter_wrapper_mock.h"
26 #include "lnn_net_ledger_mock.h"
27 #include "dsoftbus_enhance_interface.h"
28 
29 constexpr char MACTEST[BT_MAC_LEN] = "00:11:22:33:44";
30 constexpr char PEERUUID[UUID_BUF_LEN] = "021315ASD";
31 constexpr char NETWORKID[NETWORK_ID_BUF_LEN] = "123456ABD";
32 constexpr char PEERUDID[UDID_BUF_LEN] = "021315ASD";
33 constexpr char SOFTBUSVERSION[DEVICE_VERSION_SIZE_MAX] = "softBusVersion";
34 constexpr char TMPMSG[] = "{\"type\":1}";
35 constexpr int32_t TMP_LEN = 10;
36 constexpr int32_t STATE_VERSION = 2;
37 constexpr uint64_t TIMES_STAP0 = 0;
38 constexpr uint64_t TIMES_STAP1 = 1;
39 constexpr uint64_t TIMES_STAP2 = 2;
40 constexpr int32_t STATE_VERSION2 = 12;
41 constexpr int32_t KEY_SIZE0 = 0;
42 constexpr int32_t KEY_SIZE1 = 1;
43 
44 namespace OHOS {
45 using namespace testing;
46 using namespace testing::ext;
47 class LNNDataCloudSyncMockTest : public testing::Test {
48 public:
49     static void SetUpTestCase();
50     static void TearDownTestCase();
51     void SetUp();
52     void TearDown();
53 };
54 
SetUpTestCase()55 void LNNDataCloudSyncMockTest::SetUpTestCase() { }
56 
TearDownTestCase()57 void LNNDataCloudSyncMockTest::TearDownTestCase() { }
58 
SetUp()59 void LNNDataCloudSyncMockTest::SetUp() { }
60 
TearDown()61 void LNNDataCloudSyncMockTest::TearDown() { }
62 
63 /*
64  * @tc.name: DBCipherInfoSyncToCache_Test_001
65  * @tc.desc: DBCipherInfoSyncToCache
66  * @tc.type: FUNC
67  * @tc.require:
68  */
69 HWTEST_F(LNNDataCloudSyncMockTest, DBCipherInfoSyncToCache_Test_001, TestSize.Level1)
70 {
71     NiceMock<LnnDataCloudSyncInterfaceMock> DataCloudSyncMock;
72     EXPECT_CALL(DataCloudSyncMock, LnnSetRemoteBroadcastCipherInfo).WillRepeatedly(Return(SOFTBUS_OK));
73     EXPECT_CALL(DataCloudSyncMock, ConvertHexStringToBytes)
74         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
75         .WillRepeatedly(Return(SOFTBUS_OK));
76     char fieldName[FIELDNAME_MAX_LEN] = { 0 };
77     NodeInfo cacheInfo;
78     (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
79     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_BROADCAST_CIPHER_KEY));
80     const char *value = "valueTest";
81     size_t valueLength = strlen(value);
82     const char *udid = "udidTest";
83     EXPECT_EQ(
84         DBCipherInfoSyncToCache(&cacheInfo, fieldName, value, valueLength, udid), SOFTBUS_KV_CONVERT_BYTES_FAILED);
85     EXPECT_EQ(DBCipherInfoSyncToCache(&cacheInfo, fieldName, value, valueLength, udid), SOFTBUS_OK);
86     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_BROADCAST_CIPHER_IV));
87     EXPECT_CALL(DataCloudSyncMock, ConvertHexStringToBytes)
88         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
89         .WillRepeatedly(Return(SOFTBUS_OK));
90     EXPECT_EQ(
91         DBCipherInfoSyncToCache(&cacheInfo, fieldName, value, valueLength, udid), SOFTBUS_KV_CONVERT_BYTES_FAILED);
92     EXPECT_EQ(DBCipherInfoSyncToCache(&cacheInfo, fieldName, value, valueLength, udid), SOFTBUS_OK);
93     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_JSON_BROADCAST_KEY_TABLE));
94     EXPECT_EQ(DBCipherInfoSyncToCache(&cacheInfo, fieldName, value, valueLength, udid), SOFTBUS_OK);
95     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DISTRIBUTED_SWITCH));
96     EXPECT_EQ(DBCipherInfoSyncToCache(&cacheInfo, fieldName, value, valueLength, udid), SOFTBUS_OK);
97     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, value));
98     EXPECT_EQ(DBCipherInfoSyncToCache(&cacheInfo, fieldName, value, valueLength, udid), SOFTBUS_INVALID_PARAM);
99 }
100 
101 /*
102  * @tc.name: LNNDataCloudSyncMockTest_Test_001
103  * @tc.desc: DBDeviceNameInfoSyncToCache
104  * @tc.type: FUNC
105  * @tc.require:
106  */
107 HWTEST_F(LNNDataCloudSyncMockTest, LNNDataCloudSyncMockTest_Test_001, TestSize.Level1)
108 {
109     NodeInfo cacheInfo;
110     (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
111     char fieldName[FIELDNAME_MAX_LEN] = { 0 };
112     const char *value = "valueTest";
113     size_t valueLength = strlen(value);
114     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DEVICE_NAME));
115     EXPECT_EQ(DBDeviceNameInfoSyncToCache(&cacheInfo, fieldName, value, valueLength), SOFTBUS_OK);
116     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_UNIFIED_DEVICE_NAME));
117     EXPECT_EQ(DBDeviceNameInfoSyncToCache(&cacheInfo, fieldName, value, valueLength), SOFTBUS_OK);
118     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_UNIFIED_DEFAULT_DEVICE_NAME));
119     EXPECT_EQ(DBDeviceNameInfoSyncToCache(&cacheInfo, fieldName, value, valueLength), SOFTBUS_OK);
120     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_SETTINGS_NICK_NAME));
121     EXPECT_EQ(DBDeviceNameInfoSyncToCache(&cacheInfo, fieldName, value, valueLength), SOFTBUS_OK);
122     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, value));
123     EXPECT_EQ(DBDeviceNameInfoSyncToCache(&cacheInfo, fieldName, value, valueLength), SOFTBUS_INVALID_PARAM);
124 }
125 
126 /*
127  * @tc.name: DBConnectMacInfoSyncToCache_Test_001
128  * @tc.desc: DBConnectMacInfoSyncToCache
129  * @tc.type: FUNC
130  * @tc.require:
131  */
132 HWTEST_F(LNNDataCloudSyncMockTest, DBConnectMacInfoSyncToCache_Test_001, TestSize.Level1)
133 {
134     NiceMock<LnnDataCloudSyncInterfaceMock> DataCloudSyncMock;
135     EXPECT_CALL(DataCloudSyncMock, ConvertHexStringToBytes)
136         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
137         .WillRepeatedly(Return(SOFTBUS_OK));
138     char fieldName[FIELDNAME_MAX_LEN] = { 0 };
139     NodeInfo cacheInfo;
140     (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
141     const char *value = "valueTest";
142     size_t valueLength = strlen(value);
143     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_BT_MAC));
144     EXPECT_EQ(DBConnectMacInfoSyncToCache(&cacheInfo, fieldName, value, valueLength), SOFTBUS_OK);
145     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_P2P_MAC_ADDR));
146     EXPECT_EQ(DBConnectMacInfoSyncToCache(&cacheInfo, fieldName, value, valueLength), SOFTBUS_OK);
147     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DEVICE_IRK));
148     EXPECT_EQ(DBConnectMacInfoSyncToCache(&cacheInfo, fieldName, value, valueLength), SOFTBUS_KV_CONVERT_BYTES_FAILED);
149     EXPECT_EQ(DBConnectMacInfoSyncToCache(&cacheInfo, fieldName, value, valueLength), SOFTBUS_OK);
150     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DEVICE_PUB_MAC));
151     EXPECT_CALL(DataCloudSyncMock, ConvertHexStringToBytes)
152         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
153         .WillRepeatedly(Return(SOFTBUS_OK));
154     EXPECT_EQ(DBConnectMacInfoSyncToCache(&cacheInfo, fieldName, value, valueLength), SOFTBUS_KV_CONVERT_BYTES_FAILED);
155     EXPECT_EQ(DBConnectMacInfoSyncToCache(&cacheInfo, fieldName, value, valueLength), SOFTBUS_OK);
156     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, value));
157     EXPECT_EQ(DBDeviceNameInfoSyncToCache(&cacheInfo, fieldName, value, valueLength), SOFTBUS_INVALID_PARAM);
158 }
159 
160 /*
161  * @tc.name: JudgeFieldNameIsDeviceBasicInfo_Test_001
162  * @tc.desc: JudgeFieldNameIsDeviceBasicInfo
163  * @tc.type: FUNC
164  * @tc.require:
165  */
166 HWTEST_F(LNNDataCloudSyncMockTest, JudgeFieldNameIsDeviceBasicInfo_Test_001, TestSize.Level1)
167 {
168     char fieldName[FIELDNAME_MAX_LEN] = { 0 };
169     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DEVICE_NAME));
170     EXPECT_EQ(JudgeFieldNameIsDeviceBasicInfo(nullptr), false);
171     EXPECT_EQ(JudgeFieldNameIsDeviceBasicInfo(fieldName), true);
172     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_UNIFIED_DEVICE_NAME));
173     EXPECT_EQ(JudgeFieldNameIsDeviceBasicInfo(fieldName), true);
174     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_UNIFIED_DEFAULT_DEVICE_NAME));
175     EXPECT_EQ(JudgeFieldNameIsDeviceBasicInfo(fieldName), true);
176     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_SETTINGS_NICK_NAME));
177     EXPECT_EQ(JudgeFieldNameIsDeviceBasicInfo(fieldName), true);
178     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DEVICE_UDID));
179     EXPECT_EQ(JudgeFieldNameIsDeviceBasicInfo(fieldName), true);
180     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DEVICE_TYPE));
181     EXPECT_EQ(JudgeFieldNameIsDeviceBasicInfo(fieldName), true);
182     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_OS_TYPE));
183     EXPECT_EQ(JudgeFieldNameIsDeviceBasicInfo(fieldName), true);
184     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_OS_VERSION));
185     EXPECT_EQ(JudgeFieldNameIsDeviceBasicInfo(fieldName), true);
186     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DEVICE_UUID));
187     EXPECT_EQ(JudgeFieldNameIsDeviceBasicInfo(fieldName), true);
188     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DEVICE_PUB_MAC));
189     EXPECT_EQ(JudgeFieldNameIsDeviceBasicInfo(fieldName), false);
190 }
191 
192 /*
193  * @tc.name: JudgeFieldNameIsNumInfo_Test_001
194  * @tc.desc: JudgeFieldNameIsNumInfo
195  * @tc.type: FUNC
196  * @tc.require:
197  */
198 HWTEST_F(LNNDataCloudSyncMockTest, JudgeFieldNameIsNumInfo_Test_001, TestSize.Level1)
199 {
200     char fieldName[FIELDNAME_MAX_LEN] = { 0 };
201     EXPECT_EQ(JudgeFieldNameIsNumInfo(nullptr), false);
202     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_STATE_VERSION));
203     EXPECT_EQ(JudgeFieldNameIsNumInfo(fieldName), true);
204     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_TRANSPORT_PROTOCOL));
205     EXPECT_EQ(JudgeFieldNameIsNumInfo(fieldName), true);
206     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_WIFI_VERSION));
207     EXPECT_EQ(JudgeFieldNameIsNumInfo(fieldName), true);
208     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_BLE_VERSION));
209     EXPECT_EQ(JudgeFieldNameIsNumInfo(fieldName), true);
210     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_ACCOUNT_ID));
211     EXPECT_EQ(JudgeFieldNameIsNumInfo(fieldName), true);
212     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_FEATURE));
213     EXPECT_EQ(JudgeFieldNameIsNumInfo(fieldName), true);
214     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_CONN_SUB_FEATURE));
215     EXPECT_EQ(JudgeFieldNameIsNumInfo(fieldName), true);
216     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_AUTH_CAP));
217     EXPECT_EQ(JudgeFieldNameIsNumInfo(fieldName), true);
218     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DEVICE_PUB_MAC));
219     EXPECT_EQ(JudgeFieldNameIsNumInfo(fieldName), false);
220 }
221 
222 /*
223  * @tc.name: JudgeFieldNameIsConnectInfo_Test_001
224  * @tc.desc: JudgeFieldNameIsConnectInfo
225  * @tc.type: FUNC
226  * @tc.require:
227  */
228 HWTEST_F(LNNDataCloudSyncMockTest, JudgeFieldNameIsConnectInfo_Test_001, TestSize.Level1)
229 {
230     char fieldName[FIELDNAME_MAX_LEN] = { 0 };
231     EXPECT_EQ(JudgeFieldNameIsConnectInfo(nullptr), false);
232     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_NETWORK_ID));
233     EXPECT_EQ(JudgeFieldNameIsConnectInfo(fieldName), true);
234     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_PKG_VERSION));
235     EXPECT_EQ(JudgeFieldNameIsConnectInfo(fieldName), true);
236     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_BT_MAC));
237     EXPECT_EQ(JudgeFieldNameIsConnectInfo(fieldName), true);
238     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_P2P_MAC_ADDR));
239     EXPECT_EQ(JudgeFieldNameIsConnectInfo(fieldName), true);
240     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DEVICE_IRK));
241     EXPECT_EQ(JudgeFieldNameIsConnectInfo(fieldName), true);
242     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DEVICE_PUB_MAC));
243     EXPECT_EQ(JudgeFieldNameIsConnectInfo(fieldName), true);
244     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_PTK));
245     EXPECT_EQ(JudgeFieldNameIsConnectInfo(fieldName), true);
246     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_SW_VERSION));
247     EXPECT_EQ(JudgeFieldNameIsConnectInfo(fieldName), true);
248     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DEVICE_PUB_MAC));
249     EXPECT_EQ(JudgeFieldNameIsConnectInfo(fieldName), true);
250 }
251 
252 /*
253  * @tc.name: JudgeFieldNameIsCipherInfo_Test_001
254  * @tc.desc: JudgeFieldNameIsCipherInfo
255  * @tc.type: FUNC
256  * @tc.require:
257  */
258 HWTEST_F(LNNDataCloudSyncMockTest, JudgeFieldNameIsCipherInfo_Test_001, TestSize.Level1)
259 {
260     char fieldName[FIELDNAME_MAX_LEN] = { 0 };
261     EXPECT_EQ(JudgeFieldNameIsCipherInfo(nullptr), false);
262     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_BROADCAST_CIPHER_KEY));
263     EXPECT_EQ(JudgeFieldNameIsCipherInfo(fieldName), true);
264     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_BROADCAST_CIPHER_IV));
265     EXPECT_EQ(JudgeFieldNameIsCipherInfo(fieldName), true);
266     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_JSON_BROADCAST_KEY_TABLE));
267     EXPECT_EQ(JudgeFieldNameIsCipherInfo(fieldName), true);
268     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_JSON_KEY_TOTAL_LIFE));
269     EXPECT_EQ(JudgeFieldNameIsCipherInfo(fieldName), true);
270     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_JSON_KEY_TIMESTAMP_BEGIN));
271     EXPECT_EQ(JudgeFieldNameIsCipherInfo(fieldName), true);
272     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_JSON_KEY_CURRENT_INDEX));
273     EXPECT_EQ(JudgeFieldNameIsCipherInfo(fieldName), true);
274     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DISTRIBUTED_SWITCH));
275     EXPECT_EQ(JudgeFieldNameIsCipherInfo(fieldName), true);
276     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DEVICE_PUB_MAC));
277     EXPECT_EQ(JudgeFieldNameIsCipherInfo(fieldName), false);
278 }
279 
280 /*
281  * @tc.name: DBDataChangeBatchSyncToCacheInternal_Test_001
282  * @tc.desc: DBDataChangeBatchSyncToCacheInternal
283  * @tc.type: FUNC
284  * @tc.require:
285  */
286 HWTEST_F(LNNDataCloudSyncMockTest, DBDataChangeBatchSyncToCacheInternal_Test_001, TestSize.Level1)
287 {
288     char fieldName[FIELDNAME_MAX_LEN] = { 0 };
289     NodeInfo cacheInfo;
290     (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
291     const char *value = "valueTest";
292     size_t valueLength = strlen(value);
293     const char *udid = "udidTest";
294     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DEVICE_UDID));
295     EXPECT_EQ(DBDataChangeBatchSyncToCacheInternal(&cacheInfo, fieldName, value, valueLength, udid), SOFTBUS_OK);
296     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_STATE_VERSION));
297     EXPECT_EQ(DBDataChangeBatchSyncToCacheInternal(&cacheInfo, fieldName, value, valueLength, udid), SOFTBUS_OK);
298     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_PKG_VERSION));
299     EXPECT_EQ(DBDataChangeBatchSyncToCacheInternal(&cacheInfo, fieldName, value, valueLength, udid), SOFTBUS_OK);
300     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DISTRIBUTED_SWITCH));
301     EXPECT_EQ(DBDataChangeBatchSyncToCacheInternal(&cacheInfo, fieldName, value, valueLength, udid), SOFTBUS_OK);
302     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_BLE_P2P));
303     EXPECT_EQ(DBDataChangeBatchSyncToCacheInternal(&cacheInfo, fieldName, value, valueLength, udid), SOFTBUS_OK);
304     const char *value1 = "true";
305     char deviceUdid[UDID_BUF_LEN] = { 0 };
306     UpdateInfoToLedger(&cacheInfo, deviceUdid, fieldName, const_cast<char *>(value1));
307     EXPECT_EQ(DBDataChangeBatchSyncToCacheInternal(&cacheInfo, fieldName, value1, valueLength, udid), SOFTBUS_OK);
308     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, value));
309     EXPECT_EQ(
310         DBDataChangeBatchSyncToCacheInternal(&cacheInfo, fieldName, value, valueLength, udid), SOFTBUS_INVALID_PARAM);
311     EXPECT_EQ(
312         DBDataChangeBatchSyncToCacheInternal(nullptr, fieldName, value, valueLength, udid), SOFTBUS_INVALID_PARAM);
313     EXPECT_EQ(
314         DBDataChangeBatchSyncToCacheInternal(&cacheInfo, nullptr, value, valueLength, udid), SOFTBUS_INVALID_PARAM);
315     EXPECT_EQ(
316         DBDataChangeBatchSyncToCacheInternal(&cacheInfo, fieldName, nullptr, valueLength, udid), SOFTBUS_INVALID_PARAM);
317     EXPECT_EQ(DBDataChangeBatchSyncToCacheInternal(&cacheInfo, fieldName, value, valueLength, nullptr),
318         SOFTBUS_INVALID_PARAM);
319     const char *udid1 = "123456789123456789123456789123456789123456789123456789123456789123456789";
320     EXPECT_EQ(
321         DBDataChangeBatchSyncToCacheInternal(&cacheInfo, fieldName, value, valueLength, udid1), SOFTBUS_INVALID_PARAM);
322     const char *key = "key";
323     char splitKeyValue[SPLIT_KEY_NUM][SPLIT_MAX_LEN];
324     EXPECT_EQ(SplitKeyOrValue(nullptr, splitKeyValue, 0), SOFTBUS_INVALID_PARAM);
325     EXPECT_EQ(SplitKeyOrValue(key, nullptr, 0), SOFTBUS_INVALID_PARAM);
326 }
327 
328 /*
329  * @tc.name: GetInfoFromSplitKey_Test_001
330  * @tc.desc: GetInfoFromSplitKey
331  * @tc.type: FUNC
332  * @tc.require:
333  */
334 HWTEST_F(LNNDataCloudSyncMockTest, GetInfoFromSplitKey_Test_001, TestSize.Level1)
335 {
336     char splitKey[][SPLIT_MAX_LEN] = {
337         "123456",
338         "234567",
339         "345678",
340     };
341     int64_t accountId = 0;
342     char deviceUdid[UDID_BUF_LEN] = { 0 };
343     char fieldName[FIELDNAME_MAX_LEN] = { 0 };
344     EXPECT_EQ(GetInfoFromSplitKey(splitKey, &accountId, deviceUdid, fieldName), SOFTBUS_OK);
345     EXPECT_EQ(GetInfoFromSplitKey(nullptr, &accountId, deviceUdid, fieldName), SOFTBUS_INVALID_PARAM);
346     EXPECT_EQ(GetInfoFromSplitKey(splitKey, nullptr, deviceUdid, fieldName), SOFTBUS_INVALID_PARAM);
347     EXPECT_EQ(GetInfoFromSplitKey(splitKey, &accountId, nullptr, fieldName), SOFTBUS_INVALID_PARAM);
348     EXPECT_EQ(GetInfoFromSplitKey(splitKey, &accountId, deviceUdid, nullptr), SOFTBUS_INVALID_PARAM);
349     char splitValue[SPLIT_VALUE_NUM][SPLIT_MAX_LEN];
350     const char *key = "key";
351     const char *value = "value";
352     CloudSyncValue parseValue;
353     EXPECT_EQ(SplitString(nullptr, splitValue, key, value, &parseValue), SOFTBUS_INVALID_PARAM);
354     EXPECT_EQ(SplitString(splitKey, nullptr, key, value, &parseValue), SOFTBUS_INVALID_PARAM);
355     EXPECT_EQ(SplitString(splitKey, splitValue, nullptr, value, &parseValue), SOFTBUS_INVALID_PARAM);
356     EXPECT_EQ(SplitString(splitKey, splitValue, key, nullptr, &parseValue), SOFTBUS_INVALID_PARAM);
357     EXPECT_EQ(SplitString(splitKey, splitValue, key, value, nullptr), SOFTBUS_INVALID_PARAM);
358 }
359 
360 /*
361  * @tc.name: HandleDBAddChangeInternal_Test_001
362  * @tc.desc: HandleDBAddChangeInternal
363  * @tc.type: FUNC
364  * @tc.require:
365  */
366 HWTEST_F(LNNDataCloudSyncMockTest, HandleDBAddChangeInternal_Test_001, TestSize.Level1)
367 {
368     NodeInfo localCaheInfo = {
369         .stateVersion = STATE_VERSION2,
370     };
371     EXPECT_EQ(EOK, strcpy_s(localCaheInfo.deviceInfo.deviceUdid, UDID_BUF_LEN, PEERUDID));
372     NiceMock<LnnDataCloudSyncInterfaceMock> DataCloudSyncMock;
373     LnnEnhanceFuncList *pfnLnnEnhanceFuncList = LnnEnhanceFuncListGet();
374     pfnLnnEnhanceFuncList->lnnGetLocalCacheNodeInfo = LnnGetLocalCacheNodeInfo;
375     EXPECT_CALL(DataCloudSyncMock, LnnGetLocalCacheNodeInfo)
376         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
377         .WillRepeatedly(DoAll(SetArgPointee<0>(localCaheInfo), Return(SOFTBUS_OK)));
378     const char *key = "key1#key2#key3";
379     const char *value = "value1#value2#value3";
380     NodeInfo cacheInfo;
381     (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
382     EXPECT_EQ(HandleDBAddChangeInternal(key, value, &cacheInfo), SOFTBUS_INVALID_PARAM);
383     EXPECT_EQ(HandleDBAddChangeInternal(key, value, &cacheInfo), SOFTBUS_INVALID_PARAM);
384 }
385 
386 /*
387  * @tc.name: SetDBNameDataToDLedger_Test_001
388  * @tc.desc: SetDBNameDataToDLedger
389  * @tc.type: FUNC
390  * @tc.require:
391  */
392 HWTEST_F(LNNDataCloudSyncMockTest, SetDBNameDataToDLedger_Test_001, TestSize.Level1)
393 {
394     NiceMock<LnnNetLedgertInterfaceMock> NetLedgerMock;
395     EXPECT_CALL(NetLedgerMock, LnnSetDLDeviceInfoName)
396         .WillOnce(Return(SOFTBUS_NOT_FIND))
397         .WillRepeatedly(Return(SOFTBUS_OK));
398     EXPECT_CALL(NetLedgerMock, LnnSetDLUnifiedDeviceName)
399         .WillOnce(Return(SOFTBUS_NOT_FIND))
400         .WillRepeatedly(Return(SOFTBUS_OK));
401     EXPECT_CALL(NetLedgerMock, LnnSetDLUnifiedDefaultDeviceName)
402         .WillOnce(Return(SOFTBUS_NOT_FIND))
403         .WillRepeatedly(Return(SOFTBUS_OK));
404     EXPECT_CALL(NetLedgerMock, LnnSetDLDeviceNickNameByUdid)
405         .WillOnce(Return(SOFTBUS_NOT_FIND))
406         .WillRepeatedly(Return(SOFTBUS_OK));
407     NodeInfo cacheInfo;
408     (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
409     char deviceUdid[UDID_BUF_LEN] = { 0 };
410     char fieldName[FIELDNAME_MAX_LEN] = { 0 };
411     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DEVICE_NAME));
412     EXPECT_EQ(SetDBNameDataToDLedger(&cacheInfo, deviceUdid, fieldName), SOFTBUS_OK);
413     EXPECT_EQ(SetDBNameDataToDLedger(&cacheInfo, deviceUdid, fieldName), SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR);
414     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_UNIFIED_DEVICE_NAME));
415     EXPECT_EQ(SetDBNameDataToDLedger(&cacheInfo, deviceUdid, fieldName), SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR);
416     EXPECT_EQ(SetDBNameDataToDLedger(&cacheInfo, deviceUdid, fieldName), SOFTBUS_OK);
417     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_UNIFIED_DEFAULT_DEVICE_NAME));
418     EXPECT_EQ(SetDBNameDataToDLedger(&cacheInfo, deviceUdid, fieldName), SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR);
419     EXPECT_EQ(SetDBNameDataToDLedger(&cacheInfo, deviceUdid, fieldName), SOFTBUS_OK);
420     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_SETTINGS_NICK_NAME));
421     EXPECT_EQ(SetDBNameDataToDLedger(&cacheInfo, deviceUdid, fieldName), SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR);
422     EXPECT_EQ(SetDBNameDataToDLedger(&cacheInfo, deviceUdid, fieldName), SOFTBUS_OK);
423     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DISTRIBUTED_SWITCH));
424     EXPECT_EQ(SetDBNameDataToDLedger(&cacheInfo, deviceUdid, fieldName), SOFTBUS_OK);
425 }
426 
427 /*
428  * @tc.name: SetDBDataToDistributedLedger_Test_001
429  * @tc.desc: SetDBDataToDistributedLedger
430  * @tc.type: FUNC
431  * @tc.require:
432  */
433 HWTEST_F(LNNDataCloudSyncMockTest, SetDBDataToDistributedLedger_Test_001, TestSize.Level1)
434 {
435     NiceMock<LnnNetLedgertInterfaceMock> NetLedgerMock;
436     EXPECT_CALL(NetLedgerMock, LnnSetDLDeviceBroadcastCipherKey)
437         .WillOnce(Return(SOFTBUS_NOT_FIND))
438         .WillRepeatedly(Return(SOFTBUS_OK));
439     EXPECT_CALL(NetLedgerMock, LnnSetDLDeviceBroadcastCipherIv)
440         .WillOnce(Return(SOFTBUS_NOT_FIND))
441         .WillRepeatedly(Return(SOFTBUS_OK));
442     EXPECT_CALL(NetLedgerMock, LnnSetDLDeviceStateVersion)
443         .WillOnce(Return(SOFTBUS_NOT_FIND))
444         .WillRepeatedly(Return(SOFTBUS_OK));
445     NiceMock<LnnDataCloudSyncInterfaceMock> DataCloudSyncMock;
446     EXPECT_CALL(DataCloudSyncMock, LnnUpdateNetworkId)
447         .WillOnce(Return(SOFTBUS_MEM_ERR))
448         .WillRepeatedly(Return(SOFTBUS_OK));
449     NodeInfo cacheInfo;
450     (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
451     char deviceUdid[UDID_BUF_LEN] = { 0 };
452     char fieldName[FIELDNAME_MAX_LEN] = { 0 };
453     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_BROADCAST_CIPHER_KEY));
454     EXPECT_EQ(SetDBDataToDistributedLedger(&cacheInfo, deviceUdid, 0, fieldName), SOFTBUS_NOT_FIND);
455     EXPECT_EQ(SetDBDataToDistributedLedger(&cacheInfo, deviceUdid, 0, fieldName), SOFTBUS_OK);
456     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_BROADCAST_CIPHER_IV));
457     EXPECT_EQ(SetDBDataToDistributedLedger(&cacheInfo, deviceUdid, 0, fieldName), SOFTBUS_NOT_FIND);
458     EXPECT_EQ(SetDBDataToDistributedLedger(&cacheInfo, deviceUdid, 0, fieldName), SOFTBUS_OK);
459     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_NETWORK_ID));
460     EXPECT_EQ(SetDBDataToDistributedLedger(&cacheInfo, deviceUdid, 0, fieldName), SOFTBUS_MEM_ERR);
461     EXPECT_EQ(SetDBDataToDistributedLedger(&cacheInfo, deviceUdid, 0, fieldName), SOFTBUS_OK);
462     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_STATE_VERSION));
463     EXPECT_EQ(SetDBDataToDistributedLedger(&cacheInfo, deviceUdid, 0, fieldName), SOFTBUS_NOT_FIND);
464     EXPECT_EQ(SetDBDataToDistributedLedger(&cacheInfo, deviceUdid, 0, fieldName), SOFTBUS_OK);
465     EXPECT_EQ(EOK, strcpy_s(fieldName, FIELDNAME_MAX_LEN, DEVICE_INFO_DISTRIBUTED_SWITCH));
466     const char *value = "value";
467     UpdateInfoToLedger(&cacheInfo, deviceUdid, fieldName, const_cast<char *>(value));
468     EXPECT_EQ(SetDBDataToDistributedLedger(&cacheInfo, deviceUdid, 0, fieldName), SOFTBUS_OK);
469     EXPECT_EQ(SetDBDataToDistributedLedger(nullptr, deviceUdid, 0, fieldName), SOFTBUS_INVALID_PARAM);
470     EXPECT_EQ(SetDBDataToDistributedLedger(&cacheInfo, nullptr, 0, fieldName), SOFTBUS_INVALID_PARAM);
471     EXPECT_EQ(SetDBDataToDistributedLedger(&cacheInfo, deviceUdid, UDID_BUF_LEN, fieldName), SOFTBUS_INVALID_PARAM);
472     EXPECT_EQ(SetDBDataToDistributedLedger(&cacheInfo, deviceUdid, 0, nullptr), SOFTBUS_INVALID_PARAM);
473 }
474 
475 /*
476  * @tc.name: IsIgnoreUpdate_Test_001
477  * @tc.desc: IsIgnoreUpdate
478  * @tc.type: FUNC
479  * @tc.require:
480  */
481 HWTEST_F(LNNDataCloudSyncMockTest, IsIgnoreUpdate_Test_001, TestSize.Level1)
482 {
483     NodeInfo cacheInfo;
484     (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
485     char deviceUdid[UDID_BUF_LEN] = { 0 };
486     char fieldName[FIELDNAME_MAX_LEN] = { 0 };
487     const char *value = "value";
488     const char *deviceUdid1 = "123456789123456789123456789123456789123456789123456789123456789123456789";
489     UpdateInfoToLedger(nullptr, deviceUdid, fieldName, const_cast<char *>(value));
490     UpdateInfoToLedger(&cacheInfo, nullptr, fieldName, const_cast<char *>(value));
491     UpdateInfoToLedger(&cacheInfo, deviceUdid, nullptr, const_cast<char *>(value));
492     UpdateInfoToLedger(&cacheInfo, deviceUdid, fieldName, nullptr);
493     UpdateInfoToLedger(&cacheInfo, const_cast<char *>(deviceUdid1), fieldName, const_cast<char *>(value));
494     EXPECT_EQ(IsIgnoreUpdate(STATE_VERSION, TIMES_STAP0, STATE_VERSION, TIMES_STAP0), false);
495     EXPECT_EQ(IsIgnoreUpdate(STATE_VERSION, TIMES_STAP2, STATE_VERSION, TIMES_STAP1), true);
496 }
497 
498 /*
499  * @tc.name: HandleDBUpdateInternal_Test_001
500  * @tc.desc: HandleDBUpdateInternal
501  * @tc.type: FUNC
502  * @tc.require:
503  */
504 HWTEST_F(LNNDataCloudSyncMockTest, HandleDBUpdateInternal_Test_001, TestSize.Level1)
505 {
506     NiceMock<LnnDataCloudSyncInterfaceMock> DataCloudSyncMock;
507     LnnEnhanceFuncList *pfnLnnEnhanceFuncList = LnnEnhanceFuncListGet();
508     pfnLnnEnhanceFuncList->lnnRetrieveDeviceInfo = LnnRetrieveDeviceInfo;
509     pfnLnnEnhanceFuncList->lnnSaveRemoteDeviceInfo = LnnSaveRemoteDeviceInfo;
510     EXPECT_CALL(DataCloudSyncMock, LnnGenerateHexStringHash)
511         .WillOnce(Return(SOFTBUS_ENCRYPT_ERR))
512         .WillRepeatedly(Return(SOFTBUS_OK));
513     EXPECT_CALL(DataCloudSyncMock, LnnRetrieveDeviceInfo)
514         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
515         .WillRepeatedly(Return(SOFTBUS_OK));
516     EXPECT_CALL(DataCloudSyncMock, LnnSaveRemoteDeviceInfo).WillRepeatedly(Return(SOFTBUS_OK));
517     char deviceUdid[UDID_BUF_LEN] = { 0 };
518     char fieldName[FIELDNAME_MAX_LEN] = { 0 };
519     CloudSyncValue parseValue;
520     char trueValue[SPLIT_MAX_LEN] = { 0 };
521     int32_t localStateVersion = 0;
522     EXPECT_EQ(HandleDBUpdateInternal(deviceUdid, fieldName, trueValue, &parseValue, localStateVersion),
523         SOFTBUS_NETWORK_GENERATE_STR_HASH_ERR);
524     EXPECT_EQ(HandleDBUpdateInternal(deviceUdid, fieldName, trueValue, &parseValue, localStateVersion), SOFTBUS_OK);
525     EXPECT_EQ(HandleDBUpdateInternal(deviceUdid, fieldName, trueValue, &parseValue, localStateVersion), SOFTBUS_OK);
526     EXPECT_EQ(
527         HandleDBUpdateInternal(nullptr, fieldName, trueValue, &parseValue, localStateVersion), SOFTBUS_INVALID_PARAM);
528     EXPECT_EQ(
529         HandleDBUpdateInternal(deviceUdid, nullptr, trueValue, &parseValue, localStateVersion), SOFTBUS_INVALID_PARAM);
530     EXPECT_EQ(
531         HandleDBUpdateInternal(deviceUdid, fieldName, nullptr, &parseValue, localStateVersion), SOFTBUS_INVALID_PARAM);
532 }
533 
534 /*
535  * @tc.name: LnnDBDataAddChangeSyncToCache_Test_001
536  * @tc.desc: LnnDBDataAddChangeSyncToCache
537  * @tc.type: FUNC
538  * @tc.require:
539  */
540 HWTEST_F(LNNDataCloudSyncMockTest, LnnDBDataAddChangeSyncToCache_Test_001, TestSize.Level1)
541 {
542     const char **key = reinterpret_cast<const char **>(SoftBusCalloc(TMP_LEN * TMP_LEN));
543     const char **value = reinterpret_cast<const char **>(SoftBusCalloc(TMP_LEN * TMP_LEN));
544     int32_t keySize = KEY_SIZE0;
545     EXPECT_EQ(LnnDBDataAddChangeSyncToCache(nullptr, value, keySize), SOFTBUS_INVALID_PARAM);
546     EXPECT_EQ(LnnDBDataAddChangeSyncToCache(key, nullptr, keySize), SOFTBUS_INVALID_PARAM);
547 }
548 
549 /*
550  * @tc.name: LnnDBDataChangeSyncToCacheInner_Test_001
551  * @tc.desc: LnnDBDataChangeSyncToCacheInner
552  * @tc.type: FUNC
553  * @tc.require:
554  */
555 HWTEST_F(LNNDataCloudSyncMockTest, LnnDBDataChangeSyncToCacheInner_Test_001, TestSize.Level1)
556 {
557     NodeInfo cacheInfo = {
558         .accountId = 12345,
559     };
560     LnnEnhanceFuncList *pfnLnnEnhanceFuncList = LnnEnhanceFuncListGet();
561     pfnLnnEnhanceFuncList->lnnUnPackCloudSyncDeviceInfo = LnnUnPackCloudSyncDeviceInfo;
562     pfnLnnEnhanceFuncList->lnnRetrieveDeviceInfo = LnnRetrieveDeviceInfo;
563     pfnLnnEnhanceFuncList->lnnGetLocalCacheNodeInfo = LnnGetLocalCacheNodeInfo;
564     EXPECT_EQ(EOK, strcpy_s(cacheInfo.p2pInfo.p2pMac, MAC_LEN, MACTEST));
565     EXPECT_EQ(EOK, strcpy_s(cacheInfo.connectInfo.macAddr, MAC_LEN, MACTEST));
566     EXPECT_EQ(EOK, strcpy_s(cacheInfo.deviceInfo.deviceUdid, UDID_BUF_LEN, PEERUDID));
567     EXPECT_EQ(EOK, strcpy_s(cacheInfo.uuid, UUID_BUF_LEN, PEERUUID));
568     EXPECT_EQ(EOK, strcpy_s(cacheInfo.networkId, NETWORK_ID_BUF_LEN, NETWORKID));
569     EXPECT_EQ(EOK, strcpy_s(cacheInfo.deviceInfo.deviceVersion, DEVICE_VERSION_SIZE_MAX, SOFTBUSVERSION));
570     PrintSyncNodeInfo(nullptr);
571     PrintSyncNodeInfo(&cacheInfo);
572     NiceMock<LnnDataCloudSyncInterfaceMock> DataCloudSyncMock;
573     EXPECT_CALL(DataCloudSyncMock, LnnUnPackCloudSyncDeviceInfo)
574         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
575         .WillRepeatedly(DoAll(SetArgPointee<1>(cacheInfo), Return(SOFTBUS_OK)));
576     EXPECT_CALL(DataCloudSyncMock, LnnGenerateHexStringHash)
577         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
578         .WillRepeatedly(Return(SOFTBUS_OK));
579     EXPECT_CALL(DataCloudSyncMock, LnnRetrieveDeviceInfo).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
580     EXPECT_CALL(DataCloudSyncMock, LnnGetLocalCacheNodeInfo)
581         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
582         .WillRepeatedly(Return(SOFTBUS_OK));
583     const char *key = "key";
584     const char *value = TMPMSG;
585     EXPECT_EQ(LnnDBDataChangeSyncToCacheInner(key, value), SOFTBUS_INVALID_PARAM);
586     EXPECT_EQ(LnnDBDataChangeSyncToCacheInner(key, value), SOFTBUS_NETWORK_GENERATE_STR_HASH_ERR);
587     EXPECT_EQ(LnnDBDataChangeSyncToCacheInner(key, value), SOFTBUS_INVALID_PARAM);
588     EXPECT_EQ(LnnDBDataChangeSyncToCacheInner(key, value), SOFTBUS_OK);
589     EXPECT_EQ(LnnDBDataChangeSyncToCacheInner(key, value), SOFTBUS_OK);
590     EXPECT_EQ(LnnDBDataChangeSyncToCacheInner(nullptr, value), SOFTBUS_INVALID_PARAM);
591     EXPECT_EQ(LnnDBDataChangeSyncToCacheInner(key, nullptr), SOFTBUS_INVALID_PARAM);
592 }
593 
594 /*
595  * @tc.name: LnnLedgerDataChangeSyncToDB_Test_001
596  * @tc.desc: LnnLedgerDataChangeSyncToDB
597  * @tc.type: FUNC
598  * @tc.require:
599  */
600 HWTEST_F(LNNDataCloudSyncMockTest, LnnLedgerDataChangeSyncToDB_Test_001, TestSize.Level1)
601 {
602     NodeInfo localCaheInfo = {
603         .accountId = 0,
604         .stateVersion = STATE_VERSION2,
605     };
606     LnnEnhanceFuncList *pfnLnnEnhanceFuncList = LnnEnhanceFuncListGet();
607     pfnLnnEnhanceFuncList->lnnGetLocalCacheNodeInfo = LnnGetLocalCacheNodeInfo;
608     EXPECT_EQ(EOK, strcpy_s(localCaheInfo.deviceInfo.deviceUdid, UDID_BUF_LEN, PEERUDID));
609     NiceMock<LnnDataCloudSyncInterfaceMock> DataCloudSyncMock;
610     EXPECT_CALL(DataCloudSyncMock, LnnGetLocalCacheNodeInfo)
611         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
612         .WillRepeatedly(DoAll(SetArgPointee<0>(localCaheInfo), Return(SOFTBUS_OK)));
613     const char key[] = "key";
614     const char value[] = "value";
615     size_t valueLength = strlen(value);
616     EXPECT_EQ(LnnLedgerDataChangeSyncToDB(key, value, valueLength), SOFTBUS_INVALID_PARAM);
617     EXPECT_EQ(LnnLedgerDataChangeSyncToDB(key, value, valueLength), SOFTBUS_OK);
618     EXPECT_EQ(LnnLedgerDataChangeSyncToDB(nullptr, value, valueLength), SOFTBUS_INVALID_PARAM);
619     EXPECT_EQ(LnnLedgerDataChangeSyncToDB(key, nullptr, valueLength), SOFTBUS_INVALID_PARAM);
620     EXPECT_EQ(LnnLedgerDataChangeSyncToDB(key, value, KEY_MAX_LEN), SOFTBUS_INVALID_PARAM);
621 }
622 
623 /*
624  * @tc.name: PackBroadcastCipherKeyInner_Test_001
625  * @tc.desc: PackBroadcastCipherKeyInner
626  * @tc.type: FUNC
627  * @tc.require:
628  */
629 HWTEST_F(LNNDataCloudSyncMockTest, PackBroadcastCipherKeyInner_Test_001, TestSize.Level1)
630 {
631     CloudSyncInfo syncInfo;
632     LnnEnhanceFuncList *pfnLnnEnhanceFuncList = LnnEnhanceFuncListGet();
633     pfnLnnEnhanceFuncList->lnnPackCloudSyncDeviceInfo = LnnPackCloudSyncDeviceInfo;
634     pfnLnnEnhanceFuncList->lnnGetLocalBroadcastCipherInfo = LnnGetLocalBroadcastCipherInfo;
635     (void)memset_s(&syncInfo, sizeof(CloudSyncInfo), 0, sizeof(CloudSyncInfo));
636     syncInfo.broadcastCipherKey = reinterpret_cast<char *>(SoftBusCalloc(TMP_LEN));
637     ASSERT_TRUE(syncInfo.broadcastCipherKey != nullptr);
638     NiceMock<LnnDataCloudSyncInterfaceMock> DataCloudSyncMock;
639     EXPECT_CALL(DataCloudSyncMock, LnnPackCloudSyncDeviceInfo)
640         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
641         .WillRepeatedly(Return(SOFTBUS_OK));
642     EXPECT_CALL(DataCloudSyncMock, LnnGetLocalBroadcastCipherInfo)
643         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
644         .WillRepeatedly(DoAll(SetArgPointee<0>(syncInfo), Return(SOFTBUS_OK)));
645     cJSON *json = cJSON_CreateObject();
646     ASSERT_TRUE(json != nullptr);
647     NodeInfo info;
648     (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
649     EXPECT_NE(PackBroadcastCipherKeyInner(json, &info), SOFTBUS_OK);
650     EXPECT_NE(PackBroadcastCipherKeyInner(json, &info), SOFTBUS_OK);
651     EXPECT_EQ(PackBroadcastCipherKeyInner(json, &info), SOFTBUS_OK);
652     cJSON_Delete(json);
653 }
654 
655 /*
656  * @tc.name: HandleDBAddChangeInternal_Test_002
657  * @tc.desc: HandleDBAddChangeInternal test the parameter is incorrect
658  * @tc.type: FUNC
659  * @tc.require:
660  */
661 HWTEST_F(LNNDataCloudSyncMockTest, HandleDBAddChangeInternal_Test_002, TestSize.Level1)
662 {
663     NodeInfo cacheInfo = { 0 };
664     int32_t ret = HandleDBAddChangeInternal(nullptr, nullptr, &cacheInfo);
665     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
666     const char *key = "key";
667     ret = HandleDBAddChangeInternal(key, nullptr, &cacheInfo);
668     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
669 }
670 
671 /*
672  * @tc.name: HandleDBUpdateChangeInternal_Test_001
673  * @tc.desc: HandleDBUpdateChangeInternal test the parameter is incorrect
674  * @tc.type: FUNC
675  * @tc.require:
676  */
677 HWTEST_F(LNNDataCloudSyncMockTest, HandleDBUpdateChangeInternal_Test_001, TestSize.Level1)
678 {
679     const char *key = "key";
680     int32_t ret = HandleDBUpdateChangeInternal(nullptr, nullptr);
681     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
682     ret = HandleDBUpdateChangeInternal(key, nullptr);
683     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
684     ret = HandleDBUpdateChangeInternal(nullptr, nullptr);
685     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
686 }
687 
688 /*
689  * @tc.name: CheckParamValidity_Test_001
690  * @tc.desc: CheckParamValidity test parameter error and correctness
691  * @tc.type: FUNC
692  * @tc.require:
693  */
694 HWTEST_F(LNNDataCloudSyncMockTest, CheckParamValidity_Test_001, TestSize.Level1)
695 {
696     const char **key = reinterpret_cast<const char **>(SoftBusCalloc(TMP_LEN * TMP_LEN));
697     const char **value = reinterpret_cast<const char **>(SoftBusCalloc(TMP_LEN * TMP_LEN));
698     int32_t keySize = KEY_SIZE1;
699     int32_t ret = CheckParamValidity(nullptr, nullptr, keySize);
700     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
701     ret = CheckParamValidity(nullptr, value, keySize);
702     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
703     ret = CheckParamValidity(key, nullptr, keySize);
704     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
705     keySize = KEY_SIZE0;
706     ret = CheckParamValidity(key, value, keySize);
707     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
708     keySize = KEY_SIZE1;
709     ret = CheckParamValidity(key, value, keySize);
710     EXPECT_EQ(ret, SOFTBUS_OK);
711 }
712 
713 /*
714  * @tc.name: LnnDBDataAddChangeSyncToCache_Test_002
715  * @tc.desc: LnnDBDataAddChangeSyncToCache test execute success
716  * @tc.type: FUNC
717  * @tc.require:
718  */
719 HWTEST_F(LNNDataCloudSyncMockTest, LnnDBDataAddChangeSyncToCache_Test_002, TestSize.Level1)
720 {
721     const char **key = reinterpret_cast<const char **>(SoftBusCalloc(TMP_LEN * TMP_LEN));
722     const char **value = reinterpret_cast<const char **>(SoftBusCalloc(TMP_LEN * TMP_LEN));
723     int32_t keySize = KEY_SIZE1;
724     EXPECT_NE(LnnDBDataAddChangeSyncToCache(key, value, keySize), SOFTBUS_OK);
725 }
726 
727 /*
728  * @tc.name: LnnUpdateOldCacheInfo_Test_001
729  * @tc.desc: LnnUpdateOldCacheInfo test execute success
730  * @tc.type: FUNC
731  * @tc.require:
732  */
733 HWTEST_F(LNNDataCloudSyncMockTest, LnnUpdateOldCacheInfo_Test_001, TestSize.Level1)
734 {
735     NiceMock<LnnDataCloudSyncInterfaceMock> DataCloudSyncMock;
736     NodeInfo newInfo = {};
737     NodeInfo oldInfo= {};
738     UpdateDeviceNameToCache(&newInfo, &oldInfo);
739     UpdateDeviceNameToCache(&newInfo, &oldInfo);
740     UpdateDevBasicInfoToCache(&newInfo, &oldInfo);
741     int32_t ret = LnnUpdateOldCacheInfo(nullptr, nullptr);
742     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
743     ret = LnnUpdateOldCacheInfo(&newInfo, nullptr);
744     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
745     EXPECT_CALL(DataCloudSyncMock, LnnFindDeviceUdidTrustedInfoFromDb).WillRepeatedly(Return(SOFTBUS_OK));
746     ret = LnnUpdateOldCacheInfo(&newInfo, &oldInfo);
747     EXPECT_EQ(ret, SOFTBUS_OK);
748     EXPECT_CALL(DataCloudSyncMock, LnnFindDeviceUdidTrustedInfoFromDb).WillRepeatedly(Return(SOFTBUS_NOT_FIND));
749     ret = LnnUpdateOldCacheInfo(&newInfo, &oldInfo);
750     EXPECT_EQ(ret, SOFTBUS_OK);
751 }
752 
753 /*
754  * @tc.name: LnnSaveAndUpdateDistributedNode_Test_001
755  * @tc.desc: LnnSaveAndUpdateDistributedNode test parameter error
756  * @tc.type: FUNC
757  * @tc.require:
758  */
759 HWTEST_F(LNNDataCloudSyncMockTest, LnnSaveAndUpdateDistributedNode_Test_001, TestSize.Level1)
760 {
761     NodeInfo cacheInfo = {};
762     NodeInfo oldCacheInfo = {};
763     EXPECT_EQ(LnnSaveAndUpdateDistributedNode(nullptr, &oldCacheInfo), SOFTBUS_INVALID_PARAM);
764     EXPECT_EQ(LnnSaveAndUpdateDistributedNode(&cacheInfo, nullptr), SOFTBUS_INVALID_PARAM);
765 }
766 
767 /*
768  * @tc.name: LnnDeleteDevInfoSyncToDB_Test_001
769  * @tc.desc: LnnDeleteDevInfoSyncToDB test parameter error
770  * @tc.type: FUNC
771  * @tc.require:
772  */
773 HWTEST_F(LNNDataCloudSyncMockTest, LnnDeleteDevInfoSyncToDB_Test_001, TestSize.Level1)
774 {
775     EXPECT_EQ(LnnLedgerAllDataSyncToDB(nullptr, false, nullptr), SOFTBUS_INVALID_PARAM);
776     auto ret = LnnDeleteDevInfoSyncToDB(nullptr, 1);
777     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
778 }
779 
780 } // namespace OHOS
781