1 /*
2 * Copyright (c) 2021 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
19 #include "bus_center_info_key.h"
20 #include "lnn_distributed_net_ledger.h"
21 #include "lnn_lane_info.h"
22 #include "lnn_lane_manager.h"
23 #include "lnn_local_net_ledger.h"
24 #include "lnn_sync_item_info.h"
25 #include "message_handler.h"
26 #include "softbus_errcode.h"
27 #include "softbus_log.h"
28 #include "softbus_utils.h"
29
30 namespace OHOS {
31 using namespace testing::ext;
32 constexpr char NODE1_DEVICE_NAME[] = "node1_test";
33 constexpr char NODE1_UDID[] = "123456ABCDEF";
34 constexpr char NODE1_NETWORK_ID[] = "235689BNHFCF";
35 constexpr char NODE1_UUID[] = "235689BNHFCC";
36 constexpr char NODE1_BT_MAC[] = "56789TTU";
37 constexpr uint32_t NODE1_AUTH_SEQ_NUM = 100;
38 constexpr char NODE2_DEVICE_NAME[] = "node2_test";
39 constexpr char NODE2_UDID[] = "123456ABCDEG";
40 constexpr char NODE2_NETWORK_ID[] = "235689BNHFCG";
41 constexpr char NODE2_UUID[] = "235689BNHFCD";
42 constexpr char NODE2_BT_MAC[] = "56789TYU";
43 constexpr char CHANGE_DEVICE_NAME[] = "change_test";
44 constexpr char NODE3_DEVICE_NAME[] = "node3_test";
45 constexpr char NODE3_UDID[] = "123456ABCDEX";
46 constexpr char NODE3_NETWORK_ID[] = "235689BNHFCX";
47 constexpr char NODE3_UUID[] = "235689BNHFCX";
48 constexpr char NODE3_BT_MAC[] = "56789TYX";
49 constexpr char NODE4_DEVICE_NAME[] = "node4_test";
50 constexpr char NODE4_UDID[] = "123456ABCDEY";
51 constexpr char NODE4_NETWORK_ID[] = "235689BNHFCY";
52 constexpr char NODE4_UUID[] = "235689BNHFCY";
53 constexpr char NODE4_BT_MAC[] = "56789TTY";
54 constexpr uint32_t REMOTE_PROXY_PORT = 8080;
55 constexpr uint32_t REMOTE_AUTH_PORT = 7070;
56 constexpr uint32_t REMOTE_SESSION_PORT = 6060;
57 constexpr uint32_t NODE_NUM = 4;
58 constexpr char LOCAL_UDID[] = "123456LOCALTEST";
59 constexpr char LOCAL_NETWORKID[] = "235689LOCAL";
60 constexpr char LOCAL_UUID[] = "235999LOCAL";
61 constexpr char LOCAL_DEVNAME[] = "local_test";
62 constexpr char LOCAL_CHANAGE_DEVNAME[] = "local";
63 constexpr char LOCAL_BT_MAC[] = "56789TUT";
64 constexpr char LOCAL_WLAN_IP[] = "10.146.181.134";
65 constexpr char LOCAL_DEVTYPE[] = TYPE_WATCH;
66 constexpr uint32_t LOCAL_SESSION_PORT = 5000;
67 constexpr uint32_t LOCAL_AUTH_PORT = 6000;
68 constexpr uint32_t LOCAL_PROXY_PORT = 7000;
69 constexpr uint32_t BR_NUM = 0;
70 constexpr uint32_t WLAN2P4G_NUM = 1;
71 constexpr uint32_t WLAN5G_NUM = 2;
72 constexpr uint32_t LANES_NUM = 1;
73 static NodeInfo g_nodeInfo[NODE_NUM];
74 constexpr uint32_t LANE_HUB_USEC = 1000000;
75 constexpr uint32_t LANE_HUB_MSEC = 1000;
76 constexpr uint32_t LOCAL_MAX_SIZE = 128;
77 constexpr uint32_t ALL_CAPACITY = 3;
78 constexpr int32_t LANES_COUNT_MAX = 100;
79 constexpr int32_t DEFAULT_PID = 0;
80
81 class LedgerLaneHubTest : public testing::Test {
82 public:
83 static void SetUpTestCase();
84 static void TearDownTestCase();
85 void SetUp();
86 void TearDown();
87 };
88
SetUpTestCase()89 void LedgerLaneHubTest::SetUpTestCase()
90 {
91 int32_t ret = LooperInit();
92 EXPECT_TRUE(ret == SOFTBUS_OK);
93 ret = LnnInitDistributedLedger();
94 EXPECT_TRUE(ret == SOFTBUS_OK);
95 ret = LnnInitLocalLedger();
96 EXPECT_TRUE(ret == SOFTBUS_OK);
97 (void)LnnInitLaneManager();
98 GTEST_LOG_(INFO) << "LaneHubTest start.";
99 }
100
TearDownTestCase()101 void LedgerLaneHubTest::TearDownTestCase()
102 {
103 LnnDeinitLocalLedger();
104 LnnDeinitDistributedLedger();
105 LooperDeinit();
106 GTEST_LOG_(INFO) << "LaneHubTest end.";
107 }
108
SetUp()109 void LedgerLaneHubTest::SetUp()
110 {
111 }
112
TearDown()113 void LedgerLaneHubTest::TearDown()
114 {
115 }
116
ConstructBRNode(void)117 static void ConstructBRNode(void)
118 {
119 int32_t ret;
120 uint32_t cap = 0;
121 LnnSetNetCapability(&cap, BIT_BR);
122 g_nodeInfo[BR_NUM].netCapacity = cap;
123 ret = LnnSetDeviceUdid(&g_nodeInfo[BR_NUM], NODE1_UDID);
124 EXPECT_TRUE(ret == SOFTBUS_OK);
125 LnnSetBtMac(&g_nodeInfo[BR_NUM], NODE1_BT_MAC);
126 ret = LnnSetDeviceName(&g_nodeInfo[BR_NUM].deviceInfo, NODE1_DEVICE_NAME);
127 EXPECT_TRUE(ret == SOFTBUS_OK);
128 ret = strncpy_s(g_nodeInfo[BR_NUM].networkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID, strlen(NODE1_NETWORK_ID));
129 EXPECT_TRUE(ret == EOK);
130 ret = strncpy_s(g_nodeInfo[BR_NUM].uuid, UUID_BUF_LEN, NODE1_UUID, strlen(NODE1_UUID));
131 EXPECT_TRUE(ret == EOK);
132 g_nodeInfo[BR_NUM].authSeqNum = NODE1_AUTH_SEQ_NUM;
133 ret = LnnSetDiscoveryType(&g_nodeInfo[BR_NUM], DISCOVERY_TYPE_BR);
134 EXPECT_TRUE(ret == SOFTBUS_OK);
135 }
136
ConstructWlan2P4GNode(void)137 static void ConstructWlan2P4GNode(void)
138 {
139 int32_t ret;
140 uint32_t cap = 0;
141 LnnSetNetCapability(&cap, BIT_WIFI_24G);
142 g_nodeInfo[WLAN2P4G_NUM].netCapacity = cap;
143 ret = LnnSetDeviceUdid(&g_nodeInfo[WLAN2P4G_NUM], NODE2_UDID);
144 EXPECT_TRUE(ret == SOFTBUS_OK);
145 LnnSetBtMac(&g_nodeInfo[WLAN2P4G_NUM], NODE2_BT_MAC);
146 ret = LnnSetDeviceName(&g_nodeInfo[WLAN2P4G_NUM].deviceInfo, NODE2_DEVICE_NAME);
147 EXPECT_TRUE(ret == SOFTBUS_OK);
148 ret = strncpy_s(g_nodeInfo[WLAN2P4G_NUM].networkId, NETWORK_ID_BUF_LEN, NODE2_NETWORK_ID, strlen(NODE2_NETWORK_ID));
149 EXPECT_TRUE(ret == EOK);
150 ret = strncpy_s(g_nodeInfo[WLAN2P4G_NUM].uuid, UUID_BUF_LEN, NODE2_UUID, strlen(NODE2_UUID));
151 EXPECT_TRUE(ret == EOK);
152 g_nodeInfo[WLAN2P4G_NUM].authSeqNum = NODE1_AUTH_SEQ_NUM;
153 ret = LnnSetDiscoveryType(&g_nodeInfo[WLAN2P4G_NUM], DISCOVERY_TYPE_BLE);
154 EXPECT_TRUE(ret == SOFTBUS_OK);
155 ret = LnnSetProxyPort(&g_nodeInfo[WLAN2P4G_NUM], REMOTE_PROXY_PORT);
156 EXPECT_TRUE(ret == SOFTBUS_OK);
157 ret = LnnSetSessionPort(&g_nodeInfo[WLAN2P4G_NUM], REMOTE_SESSION_PORT);
158 EXPECT_TRUE(ret == SOFTBUS_OK);
159 LnnSetWiFiIp(&g_nodeInfo[WLAN2P4G_NUM], LOCAL_WLAN_IP);
160 ret = LnnSetAuthPort(&g_nodeInfo[WLAN2P4G_NUM], REMOTE_AUTH_PORT);
161 EXPECT_TRUE(ret == SOFTBUS_OK);
162 }
163
ConstructWlan5GNode(void)164 static void ConstructWlan5GNode(void)
165 {
166 int32_t ret;
167 uint32_t cap = 0;
168 LnnSetNetCapability(&cap, BIT_WIFI_5G);
169 g_nodeInfo[WLAN5G_NUM].netCapacity = cap;
170 ret = LnnSetDeviceUdid(&g_nodeInfo[WLAN5G_NUM], NODE3_UDID);
171 EXPECT_TRUE(ret == SOFTBUS_OK);
172 LnnSetBtMac(&g_nodeInfo[WLAN5G_NUM], NODE3_BT_MAC);
173 ret = LnnSetDeviceName(&g_nodeInfo[WLAN5G_NUM].deviceInfo, NODE3_DEVICE_NAME);
174 EXPECT_TRUE(ret == SOFTBUS_OK);
175 ret = strncpy_s(g_nodeInfo[WLAN5G_NUM].networkId, NETWORK_ID_BUF_LEN, NODE3_NETWORK_ID, strlen(NODE3_NETWORK_ID));
176 EXPECT_TRUE(ret == EOK);
177 ret = strncpy_s(g_nodeInfo[WLAN5G_NUM].uuid, UUID_BUF_LEN, NODE3_UUID, strlen(NODE3_UUID));
178 EXPECT_TRUE(ret == EOK);
179 g_nodeInfo[WLAN5G_NUM].authSeqNum = NODE1_AUTH_SEQ_NUM;
180 ret = LnnSetDiscoveryType(&g_nodeInfo[WLAN5G_NUM], DISCOVERY_TYPE_BLE);
181 EXPECT_TRUE(ret == SOFTBUS_OK);
182 ret = LnnSetProxyPort(&g_nodeInfo[WLAN5G_NUM], REMOTE_PROXY_PORT);
183 EXPECT_TRUE(ret == SOFTBUS_OK);
184 ret = LnnSetSessionPort(&g_nodeInfo[WLAN5G_NUM], REMOTE_SESSION_PORT);
185 EXPECT_TRUE(ret == SOFTBUS_OK);
186 LnnSetWiFiIp(&g_nodeInfo[WLAN5G_NUM], LOCAL_WLAN_IP);
187 ret = LnnSetAuthPort(&g_nodeInfo[WLAN5G_NUM], REMOTE_AUTH_PORT);
188 EXPECT_TRUE(ret == SOFTBUS_OK);
189 }
190
ConstructCommonLocalInfo(void)191 static void ConstructCommonLocalInfo(void)
192 {
193 int32_t ret = LnnSetLocalStrInfo(STRING_KEY_DEV_UDID, LOCAL_UDID);
194 EXPECT_TRUE(ret == SOFTBUS_OK);
195 ret = LnnSetLocalStrInfo(STRING_KEY_NETWORKID, LOCAL_NETWORKID);
196 EXPECT_TRUE(ret == SOFTBUS_OK);
197 ret = LnnSetLocalStrInfo(STRING_KEY_UUID, LOCAL_UUID);
198 EXPECT_TRUE(ret == SOFTBUS_OK);
199 ret = LnnSetLocalStrInfo(STRING_KEY_DEV_TYPE, LOCAL_DEVTYPE);
200 EXPECT_TRUE(ret == SOFTBUS_OK);
201 ret = LnnSetLocalStrInfo(STRING_KEY_DEV_NAME, LOCAL_DEVNAME);
202 EXPECT_TRUE(ret == SOFTBUS_OK);
203 }
204
ConstructBtLocalInfo(void)205 static void ConstructBtLocalInfo(void)
206 {
207 int32_t ret = LnnSetLocalStrInfo(STRING_KEY_BT_MAC, LOCAL_BT_MAC);
208 EXPECT_TRUE(ret == SOFTBUS_OK);
209 ret = LnnSetLocalNumInfo(NUM_KEY_NET_CAP, 1 << BIT_BR);
210 EXPECT_TRUE(ret == SOFTBUS_OK);
211 }
212
ConstructWiFiLocalInfo(bool is5G)213 static void ConstructWiFiLocalInfo(bool is5G)
214 {
215 int32_t ret = LnnSetLocalNumInfo(NUM_KEY_AUTH_PORT, LOCAL_AUTH_PORT);
216 EXPECT_TRUE(ret == SOFTBUS_OK);
217 ret = LnnSetLocalNumInfo(NUM_KEY_PROXY_PORT, LOCAL_PROXY_PORT);
218 EXPECT_TRUE(ret == SOFTBUS_OK);
219 ret = LnnSetLocalNumInfo(NUM_KEY_SESSION_PORT, LOCAL_SESSION_PORT);
220 EXPECT_TRUE(ret == SOFTBUS_OK);
221 if (is5G) {
222 ret = LnnSetLocalNumInfo(NUM_KEY_NET_CAP, 1 << BIT_WIFI_5G);
223 } else {
224 ret = LnnSetLocalNumInfo(NUM_KEY_NET_CAP, 1 << BIT_WIFI_24G);
225 }
226 EXPECT_TRUE(ret == SOFTBUS_OK);
227 ret = LnnSetLocalStrInfo(STRING_KEY_WLAN_IP, LOCAL_WLAN_IP);
228 EXPECT_TRUE(ret == SOFTBUS_OK);
229 }
230
GetCommonLocalInfo(void)231 static void GetCommonLocalInfo(void)
232 {
233 int32_t ret;
234 char des[LOCAL_MAX_SIZE] = {0};
235 ret = LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, des, LOCAL_MAX_SIZE);
236 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_UDID) == 0));
237 ret = LnnGetLocalStrInfo(STRING_KEY_NETWORKID, des, LOCAL_MAX_SIZE);
238 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_NETWORKID) == 0));
239 ret = LnnGetLocalStrInfo(STRING_KEY_UUID, des, LOCAL_MAX_SIZE);
240 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_UUID) == 0));
241 ret = LnnGetLocalStrInfo(STRING_KEY_DEV_TYPE, des, LOCAL_MAX_SIZE);
242 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_DEVTYPE) == 0));
243 ret = LnnGetLocalStrInfo(STRING_KEY_DEV_NAME, des, LOCAL_MAX_SIZE);
244 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_DEVNAME) == 0));
245 }
246
GetBTLocalInfo(void)247 static void GetBTLocalInfo(void)
248 {
249 int32_t ret;
250 char des[LOCAL_MAX_SIZE] = {0};
251 ret = LnnGetLocalStrInfo(STRING_KEY_BT_MAC, des, LOCAL_MAX_SIZE);
252 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_BT_MAC) == 0));
253 }
254
GetWiFiLocalInfo(void)255 static void GetWiFiLocalInfo(void)
256 {
257 int32_t ret;
258 int32_t port = 0;
259 ret = LnnGetLocalNumInfo(NUM_KEY_AUTH_PORT, &port);
260 EXPECT_TRUE((ret == SOFTBUS_OK) && (port == LOCAL_AUTH_PORT));
261 ret = LnnGetLocalNumInfo(NUM_KEY_PROXY_PORT, &port);
262 EXPECT_TRUE((ret == SOFTBUS_OK) && (port == LOCAL_PROXY_PORT));
263 ret = LnnGetLocalNumInfo(NUM_KEY_SESSION_PORT, &port);
264 EXPECT_TRUE((ret == SOFTBUS_OK) && (port == LOCAL_SESSION_PORT));
265 }
266
ConstructALLCapacityNode(void)267 static void ConstructALLCapacityNode(void)
268 {
269 int32_t ret;
270 uint32_t cap = 0;
271 LnnSetNetCapability(&cap, BIT_WIFI_5G);
272 LnnSetNetCapability(&cap, BIT_WIFI_24G);
273 LnnSetNetCapability(&cap, BIT_BR);
274 g_nodeInfo[ALL_CAPACITY].netCapacity = cap;
275 ret = LnnSetDeviceUdid(&g_nodeInfo[ALL_CAPACITY], NODE4_UDID);
276 EXPECT_TRUE(ret == SOFTBUS_OK);
277 LnnSetBtMac(&g_nodeInfo[ALL_CAPACITY], NODE4_BT_MAC);
278 ret = LnnSetDeviceName(&g_nodeInfo[ALL_CAPACITY].deviceInfo, NODE4_DEVICE_NAME);
279 EXPECT_TRUE(ret == SOFTBUS_OK);
280 ret = strncpy_s(g_nodeInfo[ALL_CAPACITY].networkId, NETWORK_ID_BUF_LEN, NODE4_NETWORK_ID, strlen(NODE4_NETWORK_ID));
281 EXPECT_TRUE(ret == EOK);
282 ret = strncpy_s(g_nodeInfo[ALL_CAPACITY].uuid, UUID_BUF_LEN, NODE4_UUID, strlen(NODE4_UUID));
283 EXPECT_TRUE(ret == EOK);
284 g_nodeInfo[ALL_CAPACITY].authSeqNum = NODE1_AUTH_SEQ_NUM;
285 ret = LnnSetDiscoveryType(&g_nodeInfo[ALL_CAPACITY], DISCOVERY_TYPE_BLE);
286 EXPECT_TRUE(ret == SOFTBUS_OK);
287 ret = LnnSetProxyPort(&g_nodeInfo[ALL_CAPACITY], REMOTE_PROXY_PORT);
288 EXPECT_TRUE(ret == SOFTBUS_OK);
289 ret = LnnSetSessionPort(&g_nodeInfo[ALL_CAPACITY], REMOTE_SESSION_PORT);
290 EXPECT_TRUE(ret == SOFTBUS_OK);
291 LnnSetWiFiIp(&g_nodeInfo[ALL_CAPACITY], LOCAL_WLAN_IP);
292 ret = LnnSetAuthPort(&g_nodeInfo[ALL_CAPACITY], REMOTE_AUTH_PORT);
293 EXPECT_TRUE(ret == SOFTBUS_OK);
294 }
295
ConstructAllCapacityLocalInfo()296 static void ConstructAllCapacityLocalInfo()
297 {
298 ConstructWiFiLocalInfo(false);
299 ConstructBtLocalInfo();
300 int32_t ret = LnnSetLocalNumInfo(NUM_KEY_NET_CAP, (1 << BIT_BR) | (1 << BIT_WIFI_24G) | (1 << BIT_WIFI_5G));
301 EXPECT_TRUE(ret == SOFTBUS_OK);
302 }
303
304 /*
305 * @tc.name: LANE_HUB_WLAN2P4G_MESSAGE_LANE_Test_001
306 * @tc.desc: Wlan2P4G message lane test
307 * @tc.type: FUNC
308 * @tc.require: AR000FK6IU
309 */
310 HWTEST_F(LedgerLaneHubTest, LANE_HUB_WLAN2P4G_MESSAGE_LANE_Test_001, TestSize.Level1)
311 {
312 ConstructWlan2P4GNode();
313 LnnAddOnlineNode(&g_nodeInfo[WLAN2P4G_NUM]);
314 ConstructCommonLocalInfo();
315 ConstructWiFiLocalInfo(false);
316
317 LnnLanesObject *lanesObj = LnnRequestLanesObject(NODE2_NETWORK_ID, DEFAULT_PID,
318 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
319 int32_t laneId = LnnGetLaneId(lanesObj, 0);
320 const LnnLaneInfo *laneInfo = LnnGetLaneInfo(laneId);
321 EXPECT_TRUE(laneId == LNN_LINK_TYPE_WLAN_2P4G && laneInfo);
322 LnnReleaseLanesObject(lanesObj);
323 }
324
325 /*
326 * @tc.name: LANE_HUB_WLAN2P4G_BYTES_LANE_Test_001
327 * @tc.desc: Wlan2P4G bytes lane test
328 * @tc.type: FUNC
329 * @tc.require: AR000FK6IU
330 */
331 HWTEST_F(LedgerLaneHubTest, LANE_HUB_WLAN2P4G_BYTES_LANE_Test_001, TestSize.Level1)
332 {
333 ConstructWlan2P4GNode();
334 LnnAddOnlineNode(&g_nodeInfo[WLAN2P4G_NUM]);
335 ConstructCommonLocalInfo();
336 ConstructWiFiLocalInfo(false);
337
338 LnnLanesObject *lanesObj = LnnRequestLanesObject(NODE2_NETWORK_ID, DEFAULT_PID,
339 LNN_BYTES_LANE, nullptr, LANES_NUM);
340 int32_t laneId = LnnGetLaneId(lanesObj, 0);
341 const LnnLaneInfo *laneInfo = LnnGetLaneInfo(laneId);
342 EXPECT_TRUE(laneId == LNN_LINK_TYPE_WLAN_2P4G && laneInfo != nullptr && laneInfo->isProxy == false &&
343 laneInfo->conOption.type == CONNECTION_ADDR_WLAN &&
344 strncmp(laneInfo->conOption.info.ip.ip, LOCAL_WLAN_IP, strlen(LOCAL_WLAN_IP)) == 0 &&
345 laneInfo->conOption.info.ip.port == REMOTE_SESSION_PORT);
346 LnnReleaseLanesObject(lanesObj);
347 }
348
349 /*
350 * @tc.name: LANE_HUB_WLAN2P4G_FILE_LANE_Test_001
351 * @tc.desc: Wlan2P4G file lane test
352 * @tc.type: FUNC
353 * @tc.require: AR000FK6IU
354 */
355 HWTEST_F(LedgerLaneHubTest, LANE_HUB_WLAN2P4G_FILE_LANE_Test_001, TestSize.Level1)
356 {
357 ConstructWlan2P4GNode();
358 LnnAddOnlineNode(&g_nodeInfo[WLAN2P4G_NUM]);
359 ConstructCommonLocalInfo();
360 ConstructWiFiLocalInfo(false);
361
362 LnnLanesObject *lanesObj = LnnRequestLanesObject(NODE2_NETWORK_ID, DEFAULT_PID,
363 LNN_FILE_LANE, nullptr, LANES_NUM);
364 int32_t laneId = LnnGetLaneId(lanesObj, 0);
365 const LnnLaneInfo *laneInfo = LnnGetLaneInfo(laneId);
366 EXPECT_TRUE(laneId == LNN_LINK_TYPE_WLAN_2P4G && laneInfo != nullptr && laneInfo->isProxy == false &&
367 laneInfo->conOption.type == CONNECTION_ADDR_WLAN &&
368 strncmp(laneInfo->conOption.info.ip.ip, LOCAL_WLAN_IP, strlen(LOCAL_WLAN_IP)) == 0 &&
369 laneInfo->conOption.info.ip.port == REMOTE_AUTH_PORT);
370 LnnReleaseLanesObject(lanesObj);
371 }
372
373 /*
374 * @tc.name: LANE_HUB_WLAN2P4G_STREAM_LANE_Test_001
375 * @tc.desc: Wlan2P4G stream lane test
376 * @tc.type: FUNC
377 * @tc.require: AR000FK6IU
378 */
379 HWTEST_F(LedgerLaneHubTest, LANE_HUB_WLAN2P4G_STREAM_LANE_Test_001, TestSize.Level1)
380 {
381 ConstructWlan2P4GNode();
382 LnnAddOnlineNode(&g_nodeInfo[WLAN2P4G_NUM]);
383 ConstructCommonLocalInfo();
384 ConstructWiFiLocalInfo(false);
385
386 LnnLanesObject *lanesObj = LnnRequestLanesObject(NODE2_NETWORK_ID, DEFAULT_PID,
387 LNN_STREAM_LANE, nullptr, LANES_NUM);
388 int32_t laneId = LnnGetLaneId(lanesObj, 0);
389 const LnnLaneInfo *laneInfo = LnnGetLaneInfo(laneId);
390 EXPECT_TRUE(laneId == LNN_LINK_TYPE_WLAN_2P4G && laneInfo != nullptr && laneInfo->isProxy == false &&
391 laneInfo->conOption.type == CONNECTION_ADDR_WLAN &&
392 strncmp(laneInfo->conOption.info.ip.ip, LOCAL_WLAN_IP, strlen(LOCAL_WLAN_IP)) == 0 &&
393 laneInfo->conOption.info.ip.port == REMOTE_AUTH_PORT);
394 LnnReleaseLanesObject(lanesObj);
395 }
396
397 /*
398 * @tc.name: LANE_HUB_WLAN5G_MESSAGE_LANE_Test_001
399 * @tc.desc: Wlan5G message lane test
400 * @tc.type: FUNC
401 * @tc.require: AR000FK6IU
402 */
403 HWTEST_F(LedgerLaneHubTest, LANE_HUB_WLAN5G_MESSAGE_LANE_Test_001, TestSize.Level1)
404 {
405 ConstructWlan5GNode();
406 LnnAddOnlineNode(&g_nodeInfo[WLAN5G_NUM]);
407 ConstructCommonLocalInfo();
408 ConstructWiFiLocalInfo(true);
409
410 LnnLanesObject *lanesObj = LnnRequestLanesObject(NODE3_NETWORK_ID, DEFAULT_PID,
411 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
412 int32_t laneId = LnnGetLaneId(lanesObj, 0);
413 const LnnLaneInfo *laneInfo = LnnGetLaneInfo(laneId);
414 EXPECT_TRUE(laneId == LNN_LINK_TYPE_WLAN_5G && laneInfo != nullptr);
415 LnnReleaseLanesObject(lanesObj);
416 }
417
418 /*
419 * @tc.name: LANE_HUB_WLAN5G_BYTES_LANE_Test_001
420 * @tc.desc: Wlan5G bytes lane test
421 * @tc.type: FUNC
422 * @tc.require: AR000FK6IU
423 */
424 HWTEST_F(LedgerLaneHubTest, LANE_HUB_WLAN5G_BYTES_LANE_Test_001, TestSize.Level1)
425 {
426 ConstructWlan5GNode();
427 LnnAddOnlineNode(&g_nodeInfo[WLAN5G_NUM]);
428 ConstructCommonLocalInfo();
429 ConstructWiFiLocalInfo(true);
430
431 LnnLanesObject *lanesObj = LnnRequestLanesObject(NODE3_NETWORK_ID, DEFAULT_PID,
432 LNN_BYTES_LANE, nullptr, LANES_NUM);
433 int32_t laneId = LnnGetLaneId(lanesObj, 0);
434 const LnnLaneInfo *laneInfo = LnnGetLaneInfo(laneId);
435 EXPECT_TRUE(laneId == LNN_LINK_TYPE_WLAN_5G && laneInfo != nullptr && laneInfo->isProxy == false &&
436 laneInfo->conOption.type == CONNECTION_ADDR_WLAN &&
437 strncmp(laneInfo->conOption.info.ip.ip, LOCAL_WLAN_IP, strlen(LOCAL_WLAN_IP)) == 0 &&
438 laneInfo->conOption.info.ip.port == REMOTE_SESSION_PORT);
439 LnnReleaseLanesObject(lanesObj);
440 }
441
442 /*
443 * @tc.name: LANE_HUB_WLAN5G_FILE_LANE_Test_001
444 * @tc.desc: Wlan2P4G file lane test
445 * @tc.type: FUNC
446 * @tc.require: AR000FK6IU
447 */
448 HWTEST_F(LedgerLaneHubTest, LANE_HUB_WLAN5G_FILE_LANE_Test_001, TestSize.Level1)
449 {
450 ConstructWlan2P4GNode();
451 LnnAddOnlineNode(&g_nodeInfo[WLAN5G_NUM]);
452 ConstructCommonLocalInfo();
453 ConstructWiFiLocalInfo(true);
454
455 LnnLanesObject *lanesObj = LnnRequestLanesObject(NODE3_NETWORK_ID, DEFAULT_PID,
456 LNN_FILE_LANE, nullptr, LANES_NUM);
457 int32_t laneId = LnnGetLaneId(lanesObj, 0);
458 const LnnLaneInfo *laneInfo = LnnGetLaneInfo(laneId);
459 EXPECT_TRUE(laneId == LNN_LINK_TYPE_WLAN_5G && laneInfo != nullptr && laneInfo->isProxy == false &&
460 laneInfo->conOption.type == CONNECTION_ADDR_WLAN &&
461 strncmp(laneInfo->conOption.info.ip.ip, LOCAL_WLAN_IP, strlen(LOCAL_WLAN_IP)) == 0 &&
462 laneInfo->conOption.info.ip.port == REMOTE_AUTH_PORT);
463 LnnReleaseLanesObject(lanesObj);
464 }
465
466 /*
467 * @tc.name: LANE_HUB_WLAN5G_STREAM_LANE_Test_001
468 * @tc.desc: Wlan5G stream lane test
469 * @tc.type: FUNC
470 * @tc.require: AR000FK6IU
471 */
472 HWTEST_F(LedgerLaneHubTest, LANE_HUB_WLAN5G_STREAM_LANE_Test_001, TestSize.Level1)
473 {
474 ConstructWlan2P4GNode();
475 LnnAddOnlineNode(&g_nodeInfo[WLAN5G_NUM]);
476 ConstructCommonLocalInfo();
477 ConstructWiFiLocalInfo(true);
478
479 LnnLanesObject *lanesObj = LnnRequestLanesObject(NODE3_NETWORK_ID, DEFAULT_PID,
480 LNN_STREAM_LANE, nullptr, LANES_NUM);
481 int32_t laneId = LnnGetLaneId(lanesObj, 0);
482 const LnnLaneInfo *laneInfo = LnnGetLaneInfo(laneId);
483 EXPECT_TRUE(laneId == LNN_LINK_TYPE_WLAN_5G && laneInfo != nullptr && laneInfo->isProxy == false &&
484 laneInfo->conOption.type == CONNECTION_ADDR_WLAN &&
485 strncmp(laneInfo->conOption.info.ip.ip, LOCAL_WLAN_IP, strlen(LOCAL_WLAN_IP)) == 0 &&
486 laneInfo->conOption.info.ip.port == REMOTE_AUTH_PORT);
487 LnnReleaseLanesObject(lanesObj);
488 }
489
490 /*
491 * @tc.name: LANE_HUB_BR_MESSAGE_LANE_Test_001
492 * @tc.desc: BR message lane test
493 * @tc.type: FUNC
494 * @tc.require: AR000FK6IU
495 */
496 HWTEST_F(LedgerLaneHubTest, LANE_HUB_BR_MESSAGE_LANE_Test_001, TestSize.Level1)
497 {
498 ConstructBRNode();
499 LnnAddOnlineNode(&g_nodeInfo[BR_NUM]);
500 ConstructCommonLocalInfo();
501 ConstructBtLocalInfo();
502
503 LnnLanesObject *lanesObj = LnnRequestLanesObject(NODE1_NETWORK_ID, DEFAULT_PID,
504 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
505 int32_t laneId = LnnGetLaneId(lanesObj, 0);
506 const LnnLaneInfo *laneInfo = LnnGetLaneInfo(laneId);
507 EXPECT_TRUE(laneId == LNN_LINK_TYPE_BR && laneInfo != nullptr && laneInfo->isProxy &&
508 laneInfo->conOption.type == CONNECTION_ADDR_BR &&
509 strncmp(laneInfo->conOption.info.br.brMac, NODE1_BT_MAC, strlen(NODE1_BT_MAC)) == 0);
510 LnnReleaseLanesObject(lanesObj);
511 }
512
513 /*
514 * @tc.name: LANE_HUB_BR_BYTES_LANE_Test_001
515 * @tc.desc: BR bytes lane test
516 * @tc.type: FUNC
517 * @tc.require: AR000FK6IU
518 */
519 HWTEST_F(LedgerLaneHubTest, LANE_HUB_BR_BYTES_LANE_Test_001, TestSize.Level1)
520 {
521 ConstructBRNode();
522 LnnAddOnlineNode(&g_nodeInfo[BR_NUM]);
523 ConstructCommonLocalInfo();
524 ConstructBtLocalInfo();
525
526 LnnLanesObject *lanesObj = LnnRequestLanesObject(NODE1_NETWORK_ID, DEFAULT_PID,
527 LNN_BYTES_LANE, nullptr, LANES_NUM);
528 int32_t laneId = LnnGetLaneId(lanesObj, 0);
529 const LnnLaneInfo *laneInfo = LnnGetLaneInfo(laneId);
530 EXPECT_TRUE(laneId == LNN_LINK_TYPE_BR && laneInfo != nullptr && laneInfo->isProxy &&
531 laneInfo->conOption.type == CONNECTION_ADDR_BR &&
532 strncmp(laneInfo->conOption.info.br.brMac, NODE1_BT_MAC, strlen(NODE1_BT_MAC)) == 0);
533 LnnReleaseLanesObject(lanesObj);
534 }
535
536 /*
537 * @tc.name: LANE_HUB_BR_FILE_LANE_Test_001
538 * @tc.desc: BR file lane test
539 * @tc.type: FUNC
540 * @tc.require: AR000FK6IU
541 */
542 HWTEST_F(LedgerLaneHubTest, LANE_HUB_BR_FILE_LANE_Test_001, TestSize.Level1)
543 {
544 ConstructBRNode();
545 LnnAddOnlineNode(&g_nodeInfo[BR_NUM]);
546 ConstructCommonLocalInfo();
547 ConstructBtLocalInfo();
548
549 LnnLanesObject *lanesObj = LnnRequestLanesObject(NODE1_NETWORK_ID,
550 DEFAULT_PID, LNN_FILE_LANE, nullptr, LANES_NUM);
551 int32_t laneId = LnnGetLaneId(lanesObj, 0);
552 const LnnLaneInfo *laneInfo = LnnGetLaneInfo(laneId);
553 EXPECT_TRUE(laneId == LNN_LINK_TYPE_BR && laneInfo != nullptr && laneInfo->isProxy &&
554 laneInfo->conOption.type == CONNECTION_ADDR_BR &&
555 strncmp(laneInfo->conOption.info.br.brMac, NODE1_BT_MAC, strlen(NODE1_BT_MAC)) == 0);
556 LnnReleaseLanesObject(lanesObj);
557 }
558
559 /*
560 * @tc.name: LANE_HUB_BR_STREAM_LANE_Test_001
561 * @tc.desc: BR stream lane test
562 * @tc.type: FUNC
563 * @tc.require: AR000FK6IU
564 */
565 HWTEST_F(LedgerLaneHubTest, LANE_HUB_BR_STREAM_LANE_Test_001, TestSize.Level1)
566 {
567 ConstructBRNode();
568 LnnAddOnlineNode(&g_nodeInfo[BR_NUM]);
569 ConstructCommonLocalInfo();
570 ConstructBtLocalInfo();
571
572 LnnLanesObject *lanesObj = LnnRequestLanesObject(NODE1_NETWORK_ID, DEFAULT_PID,
573 LNN_STREAM_LANE, nullptr, LANES_NUM);
574 EXPECT_TRUE(lanesObj == nullptr);
575 LnnReleaseLanesObject(lanesObj);
576 }
577
578 /*
579 * @tc.name: LANE_HUB_LnnRequestLanesObject_Test_001
580 * @tc.desc: Performance test of the LnnRequestLanesObject function
581 * @tc.type: FUNC
582 * @tc.require: AR000FK6IU
583 */
584 HWTEST_F(LedgerLaneHubTest, LANE_HUB_LnnRequestLanesObject_Test_001, TestSize.Level1)
585 {
586 struct timeval start;
587 struct timeval end;
588 ConstructBRNode();
589 LnnAddOnlineNode(&g_nodeInfo[BR_NUM]);
590 ConstructCommonLocalInfo();
591 ConstructBtLocalInfo();
592
593 int testCount = 1000;
594 int times = 0;
595 gettimeofday(&start, nullptr);
596 while (testCount--) {
597 LnnLanesObject *lanesObj = LnnRequestLanesObject(NODE1_NETWORK_ID, DEFAULT_PID,
598 LNN_FILE_LANE, nullptr, LANES_NUM);
599 EXPECT_TRUE(lanesObj != nullptr);
600 LnnReleaseLanesObject(lanesObj);
601 times++;
602 }
603 gettimeofday(&end, nullptr);
604
605 int interval = LANE_HUB_USEC * (end.tv_sec - start.tv_sec) + (end.tv_usec - start.tv_usec);
606 int threshold = LANE_HUB_MSEC * times;
607 EXPECT_LT(interval, threshold);
608 }
609
610 /*
611 * @tc.name: LEDGER_GetDistributedLedgerNode_Test_001
612 * @tc.desc: Get distributed ledger node info.
613 * @tc.type: FUNC
614 * @tc.require: AR000FK6J0
615 */
616 HWTEST_F(LedgerLaneHubTest, LEDGER_GetDistributedLedgerNode_Test_001, TestSize.Level1)
617 {
618 NodeInfo *infoNetwork = nullptr;
619 NodeInfo *infoUuid = nullptr;
620 NodeInfo *infoUdid = nullptr;
621 ConstructBRNode();
622 ConstructWlan2P4GNode();
623 LnnAddOnlineNode(&g_nodeInfo[BR_NUM]);
624 LnnAddOnlineNode(&g_nodeInfo[WLAN2P4G_NUM]);
625
626 // GET CATEGORY_NETWORK_ID and CATEGORY_UUID
627 infoNetwork = LnnGetNodeInfoById(NODE1_NETWORK_ID, CATEGORY_NETWORK_ID);
628 infoUuid = LnnGetNodeInfoById(NODE1_UUID, CATEGORY_UUID);
629 infoUdid = LnnGetNodeInfoById(NODE1_UDID, CATEGORY_UDID);
630 EXPECT_TRUE((infoNetwork == infoUuid) && (infoNetwork == infoUdid));
631 LnnRemoveNode(NODE1_UDID);
632 LnnRemoveNode(NODE2_UDID);
633 }
634
635 /*
636 * @tc.name: LEDGER_GetDistributedLedgerInfo_Test_001
637 * @tc.desc: test of the LnnGetRemoteStrInfo LnnGetDLNumInfo function
638 * @tc.type: FUNC
639 * @tc.require: AR000FK6J0
640 */
641 HWTEST_F(LedgerLaneHubTest, LEDGER_GetDistributedLedgerInfo_Test_001, TestSize.Level1)
642 {
643 char deviceName[DEVICE_NAME_BUF_LEN] = {0};
644 char macAddr[MAC_LEN] = {0};
645 int32_t ret;
646 uint32_t cap = 0;
647 ConstructBRNode();
648 LnnAddOnlineNode(&g_nodeInfo[BR_NUM]);
649
650 // STRING_KEY_DEV_NAME
651 ret = LnnGetRemoteStrInfo(NODE1_NETWORK_ID, STRING_KEY_DEV_NAME, deviceName, DEVICE_NAME_BUF_LEN);
652 EXPECT_TRUE(ret == SOFTBUS_OK);
653 EXPECT_TRUE(strcmp(deviceName, NODE1_DEVICE_NAME) == 0);
654
655 // STRING_KEY_BT_MAC
656 ret = LnnGetRemoteStrInfo(NODE1_NETWORK_ID, STRING_KEY_BT_MAC, macAddr, MAC_LEN);
657 EXPECT_TRUE(ret == SOFTBUS_OK);
658 EXPECT_TRUE(strcmp(macAddr, NODE1_BT_MAC) == 0);
659
660 // NUM_KEY_NET_CAP
661 ret = LnnGetRemoteNumInfo(NODE1_NETWORK_ID, NUM_KEY_NET_CAP, (int32_t *)&cap);
662 EXPECT_TRUE(ret == SOFTBUS_OK);
663 EXPECT_TRUE((cap & (1 << BIT_BR)) != 0);
664
665 LnnRemoveNode(NODE1_UDID);
666 }
667
668 /*
669 * @tc.name: LEDGER_DistributedLedgerChangeName_Test_001
670 * @tc.desc: test of the LnnGetRemoteStrInfo LnnSetDLDeviceInfoName function
671 * @tc.type: FUNC
672 * @tc.require: AR000FK6J0
673 */
674 HWTEST_F(LedgerLaneHubTest, LEDGER_DistributedLedgerChangeName_Test_001, TestSize.Level1)
675 {
676 char deviceName[DEVICE_NAME_BUF_LEN] = {0};
677 ConstructWlan2P4GNode();
678 LnnAddOnlineNode(&g_nodeInfo[WLAN2P4G_NUM]);
679
680 // change name
681 bool result = LnnSetDLDeviceInfoName(NODE2_UDID, CHANGE_DEVICE_NAME);
682 EXPECT_TRUE(result);
683 // STRING_KEY_DEV_NAME
684 int ret = LnnGetRemoteStrInfo(NODE2_NETWORK_ID, STRING_KEY_DEV_NAME, deviceName, DEVICE_NAME_BUF_LEN);
685 EXPECT_TRUE(ret == SOFTBUS_OK);
686 EXPECT_TRUE(strcmp(deviceName, CHANGE_DEVICE_NAME) == 0);
687 LnnRemoveNode(NODE2_UDID);
688 }
689
690 /*
691 * @tc.name: LEDGER_LocalLedgerGetInfo_Test_001
692 * @tc.desc: Performance test of the LnnGetLocalLedgerStrInfo and NumInfo function.
693 * @tc.type: FUNC
694 * @tc.require: AR000FK6J0
695 */
696 HWTEST_F(LedgerLaneHubTest, LEDGER_LocalLedgerGetInfo_Test_001, TestSize.Level1)
697 {
698 char des[LOCAL_MAX_SIZE] = {0};
699 int32_t ret;
700 ConstructCommonLocalInfo();
701 ConstructBtLocalInfo();
702 ConstructWiFiLocalInfo(false);
703 GetCommonLocalInfo();
704 GetBTLocalInfo();
705 GetWiFiLocalInfo();
706
707 // change devicename
708 ret = LnnSetLocalStrInfo(STRING_KEY_DEV_NAME, LOCAL_CHANAGE_DEVNAME);
709 EXPECT_TRUE(ret == SOFTBUS_OK);
710 ret = LnnGetLocalStrInfo(STRING_KEY_DEV_NAME, des, LOCAL_MAX_SIZE);
711 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_CHANAGE_DEVNAME) == 0));
712 }
713
714 /*
715 * @tc.name: LANE_HUB_PRELINK_LANE_Test_001
716 * @tc.desc: PreLink lane test
717 * @tc.type: FUNC
718 * @tc.require: AR000FN5VC
719 */
720 HWTEST_F(LedgerLaneHubTest, LANE_HUB_PRELINK_LANE_Test_001, TestSize.Level1)
721 {
722 ConstructALLCapacityNode();
723 LnnAddOnlineNode(&g_nodeInfo[ALL_CAPACITY]);
724 ConstructCommonLocalInfo();
725 ConstructAllCapacityLocalInfo();
726
727 LnnLanesObject *lanesObj1 = LnnRequestLanesObject(NODE4_NETWORK_ID, DEFAULT_PID,
728 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
729 LnnLanesObject *lanesObj2 = LnnRequestLanesObject(NODE4_NETWORK_ID, DEFAULT_PID,
730 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
731 int32_t laneId = LnnGetLaneId(lanesObj1, 0);
732 LnnSetLaneCount(laneId, 3); // LaneCount add 3
733 EXPECT_TRUE(LnnGetLaneScore(laneId) == THRESHOLD_LANE_QUALITY_SCORE);
734 LnnReleaseLanesObject(lanesObj1);
735 LnnReleaseLanesObject(lanesObj2);
736 LnnSetLaneCount(laneId, -3); // LaneCount subtract 3
737 EXPECT_TRUE(LnnGetLaneCount(laneId) == 0);
738 }
739
740 /*
741 * @tc.name: LANE_HUB_PRELINK_LANE_Test_002
742 * @tc.desc: PreLink lane test
743 * @tc.type: FUNC
744 * @tc.require: AR000FN5VD
745 */
746 HWTEST_F(LedgerLaneHubTest, LANE_HUB_PRELINK_LANE_Test_002, TestSize.Level1)
747 {
748 ConstructALLCapacityNode();
749 LnnAddOnlineNode(&g_nodeInfo[ALL_CAPACITY]);
750 ConstructCommonLocalInfo();
751 ConstructAllCapacityLocalInfo();
752
753 LnnLanesObject *lanesObj1 = LnnRequestLanesObject(NODE4_NETWORK_ID, DEFAULT_PID,
754 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
755 int32_t laneId1 = LnnGetLaneId(lanesObj1, 0);
756 LnnSetLaneCount(laneId1, LANE_COUNT_THRESHOLD);
757 EXPECT_TRUE(LnnGetLaneScore(laneId1) == THRESHOLD_LANE_QUALITY_SCORE);
758 LnnLanesObject *lanesObj2 = LnnRequestLanesObject(NODE4_NETWORK_ID, DEFAULT_PID,
759 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
760 int32_t laneId2 = LnnGetLaneId(lanesObj2, 0);
761 EXPECT_TRUE(laneId2 == LNN_LINK_TYPE_WLAN_5G);
762 LnnReleaseLanesObject(lanesObj1);
763 LnnReleaseLanesObject(lanesObj2);
764 LnnSetLaneCount(laneId1, -LANES_COUNT_MAX);
765 LnnSetLaneCount(laneId2, -LANES_COUNT_MAX);
766 EXPECT_TRUE(LnnGetLaneCount(laneId1) == 0);
767 EXPECT_TRUE(LnnGetLaneCount(laneId2) == 0);
768 }
769
770 /*
771 * @tc.name: LANE_HUB_SCHEDULE_LANE_Test_001
772 * @tc.desc: Schedule lane test
773 * @tc.type: FUNC
774 * @tc.require: AR000FN5V9
775 */
776 HWTEST_F(LedgerLaneHubTest, LANE_HUB_SCHEDULE_LANE_Test_001, TestSize.Level1)
777 {
778 ConstructALLCapacityNode();
779 LnnAddOnlineNode(&g_nodeInfo[ALL_CAPACITY]);
780 ConstructCommonLocalInfo();
781 ConstructAllCapacityLocalInfo();
782
783 LnnLanesObject *lanesObj1 = LnnRequestLanesObject(NODE4_NETWORK_ID, DEFAULT_PID,
784 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
785 int32_t laneId1 = LnnGetLaneId(lanesObj1, 0);
786 EXPECT_TRUE(LnnGetLaneCount(laneId1) == 1); // lane used 1 times
787 LnnLanesObject *lanesObj2 = LnnRequestLanesObject(NODE4_NETWORK_ID, DEFAULT_PID,
788 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
789 int32_t laneId2 = LnnGetLaneId(lanesObj2, 0);
790 EXPECT_TRUE(LnnGetLaneCount(laneId1) == 2); // lane used 2 times
791 LnnReleaseLanesObject(lanesObj1);
792 LnnReleaseLanesObject(lanesObj2);
793 EXPECT_TRUE(LnnGetLaneCount(laneId1) == 0);
794 EXPECT_TRUE(LnnGetLaneCount(laneId2) == 0);
795 }
796
ScheduleNotify5G(int32_t laneId,int32_t score)797 static void ScheduleNotify5G(int32_t laneId, int32_t score)
798 {
799 EXPECT_TRUE(laneId == LNN_LINK_TYPE_WLAN_5G && score == THRESHOLD_LANE_QUALITY_SCORE);
800 printf("ScheduleNotify5G laneId %d, socre %d.\n", laneId, score);
801 }
802
803 /*
804 * @tc.name: LANE_HUB_SCHEDULE_LANE_Test_002
805 * @tc.desc: Schedule lane test
806 * @tc.type: FUNC
807 * @tc.require: AR000FN5VA
808 */
809 HWTEST_F(LedgerLaneHubTest, LANE_HUB_SCHEDULE_LANE_Test_002, TestSize.Level1)
810 {
811 ConstructALLCapacityNode();
812 LnnAddOnlineNode(&g_nodeInfo[ALL_CAPACITY]);
813 ConstructCommonLocalInfo();
814 ConstructAllCapacityLocalInfo();
815
816 LnnLanesObject *lanesObj1 = LnnRequestLanesObject(NODE4_NETWORK_ID, DEFAULT_PID,
817 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
818 int32_t laneId1 = LnnGetLaneId(lanesObj1, 0);
819 (void)LnnLaneQosObserverAttach(lanesObj1, ScheduleNotify5G);
820 (void)LnnSetLaneCount(laneId1, LANE_COUNT_THRESHOLD);
821 LnnLanesObject *lanesObj2 = LnnRequestLanesObject(NODE4_NETWORK_ID, DEFAULT_PID,
822 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
823 int32_t laneId2 = LnnGetLaneId(lanesObj2, 0);
824 (void)LnnLaneQosObserverAttach(lanesObj2, ScheduleNotify5G);
825 (void)LnnSetLaneCount(laneId2, LANE_COUNT_THRESHOLD);
826 TriggerLaneMonitor();
827 LnnLanesObject *lanesObj3 = LnnRequestLanesObject(NODE4_NETWORK_ID, DEFAULT_PID,
828 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
829 int32_t laneId3 = LnnGetLaneId(lanesObj3, 0);
830 EXPECT_TRUE(laneId3 == LNN_LINK_TYPE_WLAN_5G);
831
832 LnnReleaseLanesObject(lanesObj1);
833 LnnReleaseLanesObject(lanesObj2);
834 LnnReleaseLanesObject(lanesObj3);
835 LnnLaneQosObserverDetach(lanesObj1);
836 LnnLaneQosObserverDetach(lanesObj2);
837 LnnSetLaneCount(laneId1, -LANES_COUNT_MAX);
838 LnnSetLaneCount(laneId2, -LANES_COUNT_MAX);
839 LnnSetLaneCount(laneId3, -LANES_COUNT_MAX);
840 EXPECT_TRUE(LnnGetLaneCount(laneId1) == 0);
841 EXPECT_TRUE(LnnGetLaneCount(laneId2) == 0);
842 EXPECT_TRUE(LnnGetLaneCount(laneId3) == 0);
843 }
844
845 /*
846 * @tc.name: LANE_HUB_MANAGER_LANE_Test_001
847 * @tc.desc: Manager lane test
848 * @tc.type: FUNC
849 * @tc.require: AR000FN5UO
850 */
851 HWTEST_F(LedgerLaneHubTest, LANE_HUB_MANAGER_LANE_Test_001, TestSize.Level1)
852 {
853 ConstructALLCapacityNode();
854 LnnAddOnlineNode(&g_nodeInfo[ALL_CAPACITY]);
855 ConstructCommonLocalInfo();
856 ConstructAllCapacityLocalInfo();
857
858 LnnLanesObject *lanesObj1 = LnnRequestLanesObject(NODE4_NETWORK_ID, DEFAULT_PID,
859 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
860 LnnLanesObject *lanesObj2 = LnnRequestLanesObject(NODE4_NETWORK_ID, DEFAULT_PID,
861 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
862 LnnLanesObject *lanesObj3 = LnnRequestLanesObject(NODE4_NETWORK_ID, DEFAULT_PID,
863 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
864 LnnLanesObject *lanesObj4 = LnnRequestLanesObject(NODE4_NETWORK_ID, DEFAULT_PID,
865 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
866 LnnLanesObject *lanesObj5 = LnnRequestLanesObject(NODE4_NETWORK_ID, DEFAULT_PID,
867 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
868 int32_t laneId = LnnGetLaneId(lanesObj1, 0);
869 EXPECT_TRUE(laneId == LNN_LINK_TYPE_WLAN_5G);
870 LnnReleaseLanesObject(lanesObj1);
871 LnnReleaseLanesObject(lanesObj2);
872 LnnReleaseLanesObject(lanesObj3);
873 LnnReleaseLanesObject(lanesObj4);
874 LnnReleaseLanesObject(lanesObj5);
875 LnnSetLaneCount(laneId, -LANES_COUNT_MAX);
876 EXPECT_TRUE(LnnGetLaneCount(laneId) == 0);
877 }
878
879 /*
880 * @tc.name: LANE_HUB_MANAGER_LANE_Test_002
881 * @tc.desc: Manager lane test
882 * @tc.type: FUNC
883 * @tc.require: AR000FN5UP
884 */
885 HWTEST_F(LedgerLaneHubTest, LANE_HUB_MANAGER_LANE_Test_002, TestSize.Level1)
886 {
887 ConstructALLCapacityNode();
888 LnnAddOnlineNode(&g_nodeInfo[ALL_CAPACITY]);
889 ConstructCommonLocalInfo();
890 ConstructAllCapacityLocalInfo();
891
892 LnnLanesObject *lanesObj1 = LnnRequestLanesObject(NODE4_NETWORK_ID, DEFAULT_PID,
893 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
894 LnnLanesObject *lanesObj2 = LnnRequestLanesObject(NODE4_NETWORK_ID, DEFAULT_PID,
895 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
896 int32_t laneId = LnnGetLaneId(lanesObj1, 0);
897 EXPECT_TRUE(LnnGetLaneCount(laneId) == 2); // Lane used 2 times
898 LnnReleaseLanesObject(lanesObj1);
899 LnnReleaseLanesObject(lanesObj2);
900 LnnSetLaneCount(laneId, -LANES_COUNT_MAX);
901 EXPECT_TRUE(LnnGetLaneCount(laneId) == 0);
902 }
903
904 /*
905 * @tc.name: LANE_HUB_ANALYSE_LANE_Test_001
906 * @tc.desc: Analyse lane test
907 * @tc.type: FUNC
908 * @tc.require: AR000FNSVE
909 */
910 HWTEST_F(LedgerLaneHubTest, LANE_HUB_ANALYSE_LANE_Test_001, TestSize.Level1)
911 {
912 ConstructALLCapacityNode();
913 LnnAddOnlineNode(&g_nodeInfo[ALL_CAPACITY]);
914 ConstructCommonLocalInfo();
915 ConstructAllCapacityLocalInfo();
916
917 (void)LnnSetLaneCount(LNN_LINK_TYPE_WLAN_5G, LANE_COUNT_THRESHOLD);
918 LnnLanesObject *lanesObj = LnnRequestLanesObject(NODE4_NETWORK_ID, DEFAULT_PID,
919 LNN_MESSAGE_LANE, nullptr, LANES_NUM);
920 int32_t laneId = LnnGetLaneId(lanesObj, 0);
921 EXPECT_TRUE(laneId == LNN_LINK_TYPE_WLAN_5G);
922 LnnReleaseLanesObject(lanesObj);
923 LnnSetLaneCount(LNN_LINK_TYPE_WLAN_5G, -LANES_COUNT_MAX);
924 LnnSetLaneCount(laneId, -LANES_COUNT_MAX);
925 EXPECT_TRUE(LnnGetLaneCount(laneId) == 0);
926 }
927
928 /*
929 * @tc.name: LANE_HUB_ANALYSE_LANE_Test_002
930 * @tc.desc: Analyse lane test
931 * @tc.type: FUNC
932 * @tc.require: AR000FNSVG
933 */
934 HWTEST_F(LedgerLaneHubTest, LANE_HUB_ANALYSE_LANE_Test_002, TestSize.Level1)
935 {
936 ConstructALLCapacityNode();
937 LnnAddOnlineNode(&g_nodeInfo[ALL_CAPACITY]);
938 ConstructCommonLocalInfo();
939 ConstructAllCapacityLocalInfo();
940
941 (void)LnnSetLaneCount(LNN_LINK_TYPE_WLAN_5G, LANE_COUNT_THRESHOLD);
942 int32_t socre = LnnGetLaneScore(LNN_LINK_TYPE_WLAN_5G);
943 EXPECT_TRUE(socre == THRESHOLD_LANE_QUALITY_SCORE);
944 LnnSetLaneCount(LNN_LINK_TYPE_WLAN_5G, -LANES_COUNT_MAX);
945 EXPECT_TRUE(LnnGetLaneCount(LNN_LINK_TYPE_WLAN_5G) == 0);
946 }
947
948 /*
949 * @tc.name: LANE_HUB_ANALYSE_LANE_Test_003
950 * @tc.desc: Analyse lane test
951 * @tc.type: FUNC
952 * @tc.require: AR000FNSVF
953 */
954 HWTEST_F(LedgerLaneHubTest, LANE_HUB_ANALYSE_LANE_Test_003, TestSize.Level1)
955 {
956 LnnSetLaneCount(LNN_LINK_TYPE_WLAN_5G, LANE_COUNT_THRESHOLD);
957 EXPECT_TRUE(LnnGetLaneCount(LNN_LINK_TYPE_WLAN_5G) == LANE_COUNT_THRESHOLD);
958 LnnSetLaneCount(LNN_LINK_TYPE_WLAN_5G, -LANES_COUNT_MAX);
959 EXPECT_TRUE(LnnGetLaneCount(LNN_LINK_TYPE_WLAN_5G) == 0);
960 }
961
962 /*
963 * @tc.name: LANE_HUB_LOCALINFO_LANE_Test_001
964 * @tc.desc: local info lane test
965 * @tc.type: FUNC
966 * @tc.require: AR000FNSVF
967 */
968 HWTEST_F(LedgerLaneHubTest, LANE_HUB_LOCALINFO_LANE_Test_001, TestSize.Level1)
969 {
970 ConstructALLCapacityNode();
971 LnnAddOnlineNode(&g_nodeInfo[ALL_CAPACITY]);
972 ConstructCommonLocalInfo();
973 ConstructAllCapacityLocalInfo();
974
975 (void)LnnSetLaneCount(LNN_LINK_TYPE_WLAN_5G, LANE_COUNT_THRESHOLD);
976 int32_t socre = LnnGetLaneScore(LNN_LINK_TYPE_WLAN_5G);
977 EXPECT_TRUE(socre == THRESHOLD_LANE_QUALITY_SCORE);
978 (void)LnnSetLaneCount(LNN_LINK_TYPE_WLAN_5G, -1); // LaneCount subtract 1
979 socre = LnnGetLaneScore(LNN_LINK_TYPE_WLAN_5G);
980 EXPECT_TRUE(socre == PASSING_LANE_QUALITY_SCORE);
981 LnnSetLaneCount(LNN_LINK_TYPE_WLAN_5G, -LANES_COUNT_MAX);
982 EXPECT_TRUE(LnnGetLaneCount(LNN_LINK_TYPE_WLAN_5G) == 0);
983 }
984 } // namespace OHOS
985