1 /*
2 * Copyright (c) 2022 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_node_info.h"
26 #include "lnn_local_ledger_deps_mock.h"
27 #include "softbus_adapter_mem.h"
28 #include "softbus_error_code.h"
29 #include "softbus_common.h"
30 #include "softbus_log.h"
31
32 namespace OHOS {
33 using namespace testing::ext;
34 constexpr char LOCAL_UDID[] = "123456LOCALTEST";
35 constexpr char LOCAL_DEVTYPE[] = "TYPE_WATCH";
36 constexpr char LOCAL_BT_MAC[] = "56789TUT";
37 constexpr char LOCAL_WLAN_IP[] = "10.146.181.134";
38 constexpr char LOCAL_NET_IF_NAME[] = "LOCAL";
39 constexpr char MASTER_NODE_UDID[] = "234567LOCALTEST";
40 constexpr char LOCAL_NODE_ADDR[] = "ADDR";
41 constexpr char LOCAL_P2P_MAC[] = "11:22:33:44:55";
42 constexpr char LOCAL_GO_MAC[] = "22:33:44:55:66";
43 constexpr uint32_t LOCAL_SESSION_PORT = 5000;
44 constexpr uint32_t LOCAL_AUTH_PORT = 6000;
45 constexpr uint32_t LOCAL_PROXY_PORT = 7000;
46 constexpr uint32_t LOCAL_CAPACITY = 3;
47 constexpr int32_t MASTER_WEIGHT = 10;
48 constexpr int32_t P2P_ROLE = 1;
49 constexpr uint32_t CAPABILTY = 17;
50 using namespace testing;
51 class LocalLedgerTest : public testing::Test {
52 public:
53 static void SetUpTestCase();
54 static void TearDownTestCase();
55 void SetUp();
56 void TearDown();
57 };
58
SetUpTestCase()59 void LocalLedgerTest::SetUpTestCase()
60 {
61 }
62
TearDownTestCase()63 void LocalLedgerTest::TearDownTestCase()
64 {
65 }
66
SetUp()67 void LocalLedgerTest::SetUp()
68 {
69 LOG_INFO("LocalLedgerTest start.");
70 }
71
TearDown()72 void LocalLedgerTest::TearDown()
73 {
74 }
75
76 /*
77 * @tc.name: LOCAL_LEDGER_MOCK_Test_001
78 * @tc.desc: local ledger init test
79 * @tc.type: FUNC
80 * @tc.require:
81 */
82 HWTEST_F(LocalLedgerTest, LOCAL_LEDGER_MOCK_Test_001, TestSize.Level1)
83 {
84 LocalLedgerDepsInterfaceMock localLedgerMock;
85 EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
86 EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_ERR));
87 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_ERR);
88 }
89
90 /*
91 * @tc.name: LOCAL_LEDGER_MOCK_Test_002
92 * @tc.desc: local ledger init and deinit test
93 * @tc.type: FUNC
94 * @tc.require:
95 */
96 HWTEST_F(LocalLedgerTest, LOCAL_LEDGER_MOCK_Test_002, TestSize.Level1)
97 {
98 LocalLedgerDepsInterfaceMock localLedgerMock;
99 EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
100 EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
101 EXPECT_CALL(localLedgerMock,
102 GetCommonDevInfo(_, NotNull(), _)).WillRepeatedly(localLedgerMock.LedgerGetCommonDevInfo);
103 EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
104 EXPECT_CALL(localLedgerMock,
105 SoftBusRegBusCenterVarDump(_, _)).WillRepeatedly(localLedgerMock.LedgerSoftBusRegBusCenterVarDump);
106 int32_t ret = LnnInitLocalLedger();
107 EXPECT_TRUE(ret == SOFTBUS_OK);
108 ret = LnnInitLocalLedger();
109 EXPECT_TRUE(ret == SOFTBUS_OK);
110 }
111
112 /*
113 * @tc.name: LOCAL_LEDGER_MOCK_Test_003
114 * @tc.desc: local ledger delay init test
115 * @tc.type: FUNC
116 * @tc.require:
117 */
118 HWTEST_F(LocalLedgerTest, LOCAL_LEDGER_MOCK_Test_003, TestSize.Level1)
119 {
120 LocalLedgerDepsInterfaceMock localLedgerMock;
121 EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_ERR));
122 EXPECT_CALL(localLedgerMock, LnnInitOhosAccount()).WillRepeatedly(Return(SOFTBUS_ERR));
123 EXPECT_TRUE(LnnInitLocalLedgerDelay() == SOFTBUS_ERR);
124 }
125
126 /*
127 * @tc.name: LOCAL_LEDGER_MOCK_Test_004
128 * @tc.desc: lnn local key table test
129 * @tc.type: FUNC
130 * @tc.require:
131 */
132 HWTEST_F(LocalLedgerTest, LOCAL_LEDGER_MOCK_Test_004, TestSize.Level1)
133 {
134 static InfoKey getLocalStringInfoKeyTable[] = {
135 STRING_KEY_HICE_VERSION,
136 STRING_KEY_DEV_UDID,
137 STRING_KEY_NETWORKID,
138 STRING_KEY_UUID,
139 STRING_KEY_DEV_TYPE,
140 STRING_KEY_DEV_NAME,
141 STRING_KEY_BT_MAC,
142 STRING_KEY_WLAN_IP,
143 STRING_KEY_NET_IF_NAME,
144 STRING_KEY_MASTER_NODE_UDID,
145 STRING_KEY_NODE_ADDR,
146 STRING_KEY_P2P_MAC,
147 STRING_KEY_P2P_GO_MAC,
148 STRING_KEY_OFFLINE_CODE
149 };
150 char buf[UDID_BUF_LEN] = {0};
151 int32_t ret;
152 uint32_t i;
153 LnnSetLocalStrInfo(STRING_KEY_DEV_UDID, LOCAL_UDID);
154 for (i = 0; i < sizeof(getLocalStringInfoKeyTable) / sizeof(InfoKey); i++) {
155 ret = LnnGetLocalStrInfo(getLocalStringInfoKeyTable[i], nullptr, UDID_BUF_LEN);
156 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
157 }
158 for (i = 0; i < sizeof(getLocalStringInfoKeyTable) / sizeof(InfoKey); i++) {
159 (void)memset_s(buf, UDID_BUF_LEN, 0, UDID_BUF_LEN);
160 ret = LnnGetLocalStrInfo(getLocalStringInfoKeyTable[i], buf, UDID_BUF_LEN);
161 EXPECT_TRUE(ret == SOFTBUS_OK);
162 }
163 }
164
165 /*
166 * @tc.name: LOCAL_LEDGER_MOCK_Test_005
167 * @tc.desc: lnn local key table test
168 * @tc.type: FUNC
169 * @tc.require:
170 */
171 HWTEST_F(LocalLedgerTest, LOCAL_LEDGER_MOCK_Test_005, TestSize.Level1)
172 {
173 int32_t ret = LnnSetLocalStrInfo(STRING_KEY_DEV_UDID, LOCAL_UDID);
174 EXPECT_TRUE(ret == SOFTBUS_OK);
175 ret = LnnSetLocalStrInfo(STRING_KEY_DEV_TYPE, LOCAL_DEVTYPE);
176 EXPECT_TRUE(ret == SOFTBUS_ERR);
177 ret = LnnSetLocalStrInfo(STRING_KEY_BT_MAC, LOCAL_BT_MAC);
178 EXPECT_TRUE(ret == SOFTBUS_OK);
179 ret = LnnSetLocalStrInfo(STRING_KEY_WLAN_IP, LOCAL_WLAN_IP);
180 EXPECT_TRUE(ret == SOFTBUS_OK);
181 ret = LnnSetLocalStrInfo(STRING_KEY_NET_IF_NAME, LOCAL_NET_IF_NAME);
182 EXPECT_TRUE(ret == SOFTBUS_OK);
183 ret = LnnSetLocalStrInfo(STRING_KEY_MASTER_NODE_UDID, MASTER_NODE_UDID);
184 EXPECT_TRUE(ret == SOFTBUS_OK);
185 ret = LnnSetLocalStrInfo(STRING_KEY_NODE_ADDR, LOCAL_NODE_ADDR);
186 EXPECT_TRUE(ret == SOFTBUS_OK);
187 ret = LnnSetLocalStrInfo(STRING_KEY_P2P_MAC, LOCAL_P2P_MAC);
188 EXPECT_TRUE(ret == SOFTBUS_OK);
189 ret = LnnSetLocalStrInfo(STRING_KEY_P2P_GO_MAC, LOCAL_GO_MAC);
190 EXPECT_TRUE(ret == SOFTBUS_OK);
191 }
192
193 /*
194 * @tc.name: LOCAL_LEDGER_MOCK_Test_006
195 * @tc.desc: lnn local key table test
196 * @tc.type: FUNC
197 * @tc.require:
198 */
199 HWTEST_F(LocalLedgerTest, LOCAL_LEDGER_MOCK_Test_006, TestSize.Level1)
200 {
201 static InfoKey getLocalNumInfoKeyTable[] = {
202 NUM_KEY_SESSION_PORT,
203 NUM_KEY_AUTH_PORT,
204 NUM_KEY_PROXY_PORT,
205 NUM_KEY_NET_CAP,
206 NUM_KEY_DISCOVERY_TYPE,
207 NUM_KEY_DEV_TYPE_ID,
208 NUM_KEY_MASTER_NODE_WEIGHT,
209 NUM_KEY_P2P_ROLE
210 };
211 int32_t ret, info;
212 LnnSetLocalNumInfo(NUM_KEY_AUTH_PORT, LOCAL_AUTH_PORT);
213 for (uint32_t i = 0; i < sizeof(getLocalNumInfoKeyTable) / sizeof(InfoKey); i++) {
214 info = 0;
215 ret = LnnGetLocalNumInfo(getLocalNumInfoKeyTable[i], &info);
216 EXPECT_TRUE(ret == SOFTBUS_OK);
217 }
218 }
219
220 /*
221 * @tc.name: LOCAL_LEDGER_MOCK_Test_007
222 * @tc.desc: lnn local key table test
223 * @tc.type: FUNC
224 * @tc.require:
225 */
226 HWTEST_F(LocalLedgerTest, LOCAL_LEDGER_MOCK_Test_007, TestSize.Level1)
227 {
228 int32_t ret = LnnSetLocalNumInfo(NUM_KEY_SESSION_PORT, LOCAL_SESSION_PORT);
229 EXPECT_TRUE(ret == SOFTBUS_OK);
230 ret = LnnSetLocalNumInfo(NUM_KEY_AUTH_PORT, LOCAL_AUTH_PORT);
231 EXPECT_TRUE(ret == SOFTBUS_OK);
232 ret = LnnSetLocalNumInfo(NUM_KEY_PROXY_PORT, LOCAL_PROXY_PORT);
233 EXPECT_TRUE(ret == SOFTBUS_OK);
234 ret = LnnSetLocalNumInfo(NUM_KEY_NET_CAP, LOCAL_CAPACITY);
235 EXPECT_TRUE(ret == SOFTBUS_OK);
236 ret = LnnSetLocalNumInfo(NUM_KEY_MASTER_NODE_WEIGHT, MASTER_WEIGHT);
237 EXPECT_TRUE(ret == SOFTBUS_OK);
238 ret = LnnSetLocalNumInfo(NUM_KEY_P2P_ROLE, P2P_ROLE);
239 EXPECT_TRUE(ret == SOFTBUS_OK);
240 }
241
242 /*
243 * @tc.name: LOCAL_LEDGER_MOCK_Test_008
244 * @tc.desc: local ledger init test
245 * @tc.type: FUNC
246 * @tc.require:
247 */
248 HWTEST_F(LocalLedgerTest, LOCAL_LEDGER_MOCK_Test_008, TestSize.Level1)
249 {
250 LocalLedgerDepsInterfaceMock localLedgerMock;
251 EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
252 EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
253 EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_ERR));
254 EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
255 EXPECT_CALL(localLedgerMock, SoftBusRegBusCenterVarDump(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
256 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
257 }
258
259 /*
260 * @tc.name: LOCAL_LEDGER_MOCK_Test_009
261 * @tc.desc: local ledger init test
262 * @tc.type: FUNC
263 * @tc.require:
264 */
265 HWTEST_F(LocalLedgerTest, LOCAL_LEDGER_MOCK_Test_009, TestSize.Level1)
266 {
267 LocalLedgerDepsInterfaceMock localLedgerMock;
268 EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
269 EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
270 EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
271 EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_ERR));
272 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
273 }
274
275 /*
276 * @tc.name: LOCAL_LEDGER_MOCK_Test_010
277 * @tc.desc: local ledger init test
278 * @tc.type: FUNC
279 * @tc.require:
280 */
281 HWTEST_F(LocalLedgerTest, LOCAL_LEDGER_MOCK_Test_010, TestSize.Level1)
282 {
283 LocalLedgerDepsInterfaceMock localLedgerMock;
284 EXPECT_CALL(localLedgerMock, LnnGetNetCapabilty()).WillRepeatedly(Return(CAPABILTY));
285 EXPECT_CALL(localLedgerMock, SoftBusGenerateRandomArray(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
286 EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
287 EXPECT_CALL(localLedgerMock, LnnInitLocalP2pInfo(_)).WillRepeatedly(Return(SOFTBUS_OK));
288 EXPECT_CALL(localLedgerMock, SoftBusRegBusCenterVarDump(_, _)).WillRepeatedly(Return(SOFTBUS_ERR));
289 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
290 }
291
292 /*
293 * @tc.name: LOCAL_LEDGER_MOCK_Test_011
294 * @tc.desc: local ledger init test
295 * @tc.type: FUNC
296 * @tc.require:
297 */
298 HWTEST_F(LocalLedgerTest, LOCAL_LEDGER_MOCK_Test_011, TestSize.Level1)
299 {
300 LocalLedgerDepsInterfaceMock localLedgerMock;
301 EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
302 EXPECT_CALL(localLedgerMock, LnnInitOhosAccount()).WillRepeatedly(Return(SOFTBUS_ERR));
303 EXPECT_TRUE(LnnInitLocalLedgerDelay() == SOFTBUS_ERR);
304 }
305
306 /*
307 * @tc.name: LOCAL_LEDGER_MOCK_Test_012
308 * @tc.desc: local ledger init test
309 * @tc.type: FUNC
310 * @tc.require:
311 */
312 HWTEST_F(LocalLedgerTest, LOCAL_LEDGER_MOCK_Test_012, TestSize.Level1)
313 {
314 LocalLedgerDepsInterfaceMock localLedgerMock;
315 EXPECT_CALL(localLedgerMock, GetCommonDevInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
316 EXPECT_CALL(localLedgerMock, LnnInitOhosAccount()).WillRepeatedly(Return(SOFTBUS_OK));
317 EXPECT_TRUE(LnnInitLocalLedgerDelay() == SOFTBUS_OK);
318 }
319 } // namespace OHOS
320