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 #include <cstdint>
22
23 #include "bus_center_manager.h"
24 #include "lnn_decision_db.h"
25 #include "lnn_device_info.h"
26 #include "lnn_distributed_net_ledger.h"
27 #include "lnn_huks_utils.h"
28 #include "lnn_local_net_ledger.h"
29 #include "lnn_meta_node_ledger.h"
30 #include "lnn_net_capability.h"
31 #include "lnn_net_ledger.h"
32 #include "lnn_node_info.h"
33 #include "softbus_adapter_mem.h"
34 #include "softbus_errcode.h"
35 #include "softbus_feature_config.h"
36 #include "softbus_log.h"
37 #include "softbus_utils.h"
38
39 #define ONE_BIT_MAX_HEX 15
40 #define DEVICE_TYPE_MAX_LENGTH 3
41 #define LEFT_SHIFT_DEVICE_TYPE_LENGTH (DEVICE_TYPE_MAX_LENGTH * 4)
42
43 namespace OHOS {
44 using namespace testing::ext;
45 constexpr char NODE_DEVICE_NAME[] = "node1_test";
46 constexpr char INVALID_DEVICE_NAME[] =
47 "ASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJK\
48 LPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJ\
49 KLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLP";
50 constexpr char DEVICE_TYPE[] = "PAD";
51 constexpr char INVALID_DEVICE_TYPE[] = "PADPAD";
52 constexpr int32_t PORT = 1;
53 constexpr uint64_t PROTOCOLS = 1;
54 constexpr char LOCAL_NETWORKID[] = "123456LOCAL";
55 constexpr char REMOTE_NETWORKID[] = "234567REMOTE";
56 constexpr uint32_t BUF_LEN = 128;
57 constexpr int32_t KEY_MAX_INDEX = 11;
58 constexpr uint16_t DATA_CHANGE_FLAG = 1;
59 constexpr char LOCAL_UDID[] = "123456LOCALTEST";
60 constexpr char LOCAL_UUID[] = "235999LOCAL";
61 constexpr char LOCAL_BT_MAC[] = "56789TUT";
62 constexpr char LOCAL_WLAN_IP[] = "10.146.181.134";
63 constexpr int32_t DEFAULT_FD = 1;
64 using namespace testing;
65 class NetLedgerCommonTest : public testing::Test {
66 public:
67 static void SetUpTestCase();
68 static void TearDownTestCase();
69 void SetUp();
70 void TearDown();
71 };
72
SetUpTestCase()73 void NetLedgerCommonTest::SetUpTestCase()
74 {
75 }
76
TearDownTestCase()77 void NetLedgerCommonTest::TearDownTestCase()
78 {
79 }
80
SetUp()81 void NetLedgerCommonTest::SetUp()
82 {
83 LOG_INFO("NetLedgerCommonTest start.");
84 }
85
TearDown()86 void NetLedgerCommonTest::TearDown()
87 {
88 }
89
90 /*
91 * @tc.name: LNN_DEVICE_INFO_Test_001
92 * @tc.desc: lnn device info function test
93 * @tc.type: FUNC
94 * @tc.require:
95 */
96 HWTEST_F(NetLedgerCommonTest, LNN_DEVICE_INFO_Test_001, TestSize.Level1)
97 {
98 DeviceBasicInfo info;
99 uint16_t typeId = 0;
100 int32_t ret = memset_s(&info, sizeof(DeviceBasicInfo), 0, sizeof(DeviceBasicInfo));
101 EXPECT_TRUE(ret == EOK);
102 EXPECT_TRUE(LnnGetDeviceName(nullptr) == NULL);
103 LnnGetDeviceName(&info);
104 EXPECT_TRUE(LnnSetDeviceName(nullptr, NODE_DEVICE_NAME) == SOFTBUS_INVALID_PARAM);
105 EXPECT_TRUE(LnnSetDeviceName(&info, nullptr) == SOFTBUS_INVALID_PARAM);
106 EXPECT_TRUE(LnnSetDeviceName(&info, INVALID_DEVICE_NAME) == SOFTBUS_INVALID_PARAM);
107 EXPECT_TRUE(LnnSetDeviceName(&info, NODE_DEVICE_NAME) == SOFTBUS_OK);
108 EXPECT_TRUE(LnnGetDeviceTypeId(nullptr, &typeId) == SOFTBUS_INVALID_PARAM);
109 EXPECT_TRUE(LnnGetDeviceTypeId(&info, nullptr) == SOFTBUS_INVALID_PARAM);
110 EXPECT_TRUE(LnnGetDeviceTypeId(&info, &typeId) == SOFTBUS_OK);
111 EXPECT_TRUE(LnnConvertDeviceTypeToId(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
112 EXPECT_TRUE(LnnConvertDeviceTypeToId(INVALID_DEVICE_TYPE, &typeId) == SOFTBUS_ERR);
113 EXPECT_TRUE(LnnConvertDeviceTypeToId(DEVICE_TYPE, &typeId) == SOFTBUS_OK);
114 typeId = 0;
115 LnnConvertIdToDeviceType(TYPE_WATCH_ID);
116 LnnConvertIdToDeviceType(typeId);
117 typeId = ONE_BIT_MAX_HEX << LEFT_SHIFT_DEVICE_TYPE_LENGTH;
118 EXPECT_TRUE(LnnConvertIdToDeviceType(typeId) != nullptr);
119 }
120
121 /*
122 * @tc.name: LNN_HUKS_UTILS_Test_001
123 * @tc.desc: lnn huks utils function test
124 * @tc.type: FUNC
125 * @tc.require:
126 */
127 HWTEST_F(NetLedgerCommonTest, LNN_HUKS_UTILS_Test_001, TestSize.Level1)
128 {
129 struct HksBlob keyAlias;
130 (void)memset_s(&keyAlias, sizeof(HksBlob), 0, sizeof(HksBlob));
131 EXPECT_TRUE(LnnGenerateKeyByHuks(nullptr) == SOFTBUS_INVALID_PARAM);
132 EXPECT_TRUE(LnnGenerateKeyByHuks(&keyAlias) == SOFTBUS_ERR);
133 EXPECT_TRUE(LnnDeleteKeyByHuks(nullptr) == SOFTBUS_INVALID_PARAM);
134 EXPECT_TRUE(LnnDeleteKeyByHuks(&keyAlias) == SOFTBUS_OK);
135 EXPECT_TRUE(LnnEncryptDataByHuks(nullptr, nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
136 EXPECT_TRUE(LnnDecryptDataByHuks(nullptr, nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
137 }
138
139 /*
140 * @tc.name: LNN_NET_CAPABILITY_Test_001
141 * @tc.desc: lnn net capability function test
142 * @tc.type: FUNC
143 * @tc.require:
144 */
145 HWTEST_F(NetLedgerCommonTest, LNN_NET_CAPABILITY_Test_001, TestSize.Level1)
146 {
147 uint32_t capability = 0;
148 EXPECT_TRUE(LnnSetNetCapability(nullptr, BIT_COUNT) == SOFTBUS_INVALID_PARAM);
149 EXPECT_TRUE(LnnClearNetCapability(nullptr, BIT_COUNT) == SOFTBUS_INVALID_PARAM);
150 EXPECT_TRUE(LnnClearNetCapability(&capability, BIT_BLE) == SOFTBUS_OK);
151 }
152
153 /*
154 * @tc.name: LNN_NODE_INFO_Test_001
155 * @tc.desc: lnn node info function test
156 * @tc.type: FUNC
157 * @tc.require:
158 */
159 HWTEST_F(NetLedgerCommonTest, LNN_NODE_INFO_Test_001, TestSize.Level1)
160 {
161 EXPECT_TRUE(LnnHasDiscoveryType(nullptr, DISCOVERY_TYPE_WIFI) == false);
162 EXPECT_TRUE(LnnGetDeviceUdid(nullptr) == nullptr);
163 EXPECT_TRUE(LnnSetDeviceUdid(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
164 EXPECT_TRUE(LnnSetDiscoveryType(nullptr, DISCOVERY_TYPE_WIFI) == SOFTBUS_INVALID_PARAM);
165 EXPECT_TRUE(LnnClearDiscoveryType(nullptr, DISCOVERY_TYPE_WIFI) == SOFTBUS_INVALID_PARAM);
166 EXPECT_TRUE(LnnIsNodeOnline(nullptr) == false);
167 LnnSetNodeConnStatus(nullptr, STATUS_ONLINE);
168 LnnGetBtMac(nullptr);
169 LnnSetBtMac(nullptr, nullptr);
170 LnnGetNetIfName(nullptr);
171 LnnSetNetIfName(nullptr, nullptr);
172 LnnGetWiFiIp(nullptr);
173 LnnSetWiFiIp(nullptr, nullptr);
174 EXPECT_TRUE(LnnGetMasterUdid(nullptr) == nullptr);
175 EXPECT_TRUE(LnnSetMasterUdid(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
176 EXPECT_TRUE(LnnGetAuthPort(nullptr) == SOFTBUS_INVALID_PARAM);
177 EXPECT_TRUE(LnnSetAuthPort(nullptr, PORT) == SOFTBUS_INVALID_PARAM);
178 EXPECT_TRUE(LnnGetSessionPort(nullptr) == SOFTBUS_INVALID_PARAM);
179 EXPECT_TRUE(LnnSetSessionPort(nullptr, PORT) == SOFTBUS_INVALID_PARAM);
180 EXPECT_TRUE(LnnGetProxyPort(nullptr) == SOFTBUS_INVALID_PARAM);
181 EXPECT_TRUE(LnnSetProxyPort(nullptr, PORT) == SOFTBUS_OK);
182 EXPECT_TRUE(LnnSetP2pRole(nullptr, PORT) == SOFTBUS_INVALID_PARAM);
183 EXPECT_TRUE(LnnGetP2pRole(nullptr) == 0);
184 EXPECT_TRUE(LnnSetP2pMac(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
185 EXPECT_TRUE(LnnGetP2pMac(nullptr) == nullptr);
186 EXPECT_TRUE(LnnSetP2pGoMac(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
187 EXPECT_TRUE(LnnGetP2pGoMac(nullptr) == nullptr);
188 EXPECT_TRUE(LnnGetSupportedProtocols(nullptr) == 0);
189 EXPECT_TRUE(LnnSetSupportedProtocols(nullptr, PROTOCOLS) == SOFTBUS_OK);
190 }
191
192 /*
193 * @tc.name: LNN_NET_LEDGER_Test_001
194 * @tc.desc: lnn net ledger function test
195 * @tc.type: FUNC
196 * @tc.require:
197 */
198 HWTEST_F(NetLedgerCommonTest, LNN_NET_LEDGER_Test_001, TestSize.Level1)
199 {
200 int32_t i;
201 EXPECT_TRUE(LnnInitNetLedger() == SOFTBUS_OK);
202 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_NETWORKID, LOCAL_NETWORKID) == SOFTBUS_OK);
203 uint8_t info[BUF_LEN] = {0};
204 EXPECT_TRUE(LnnGetNodeKeyInfo(nullptr, 0, info, BUF_LEN) == SOFTBUS_ERR);
205 EXPECT_TRUE(LnnGetNodeKeyInfo(LOCAL_NETWORKID, 0, info, BUF_LEN) == SOFTBUS_ERR);
206 EXPECT_TRUE(LnnGetNodeKeyInfo(LOCAL_NETWORKID, KEY_MAX_INDEX - 1, info, BUF_LEN) == SOFTBUS_ERR);
207 for (i = 1; i < KEY_MAX_INDEX - 1; i++) {
208 EXPECT_TRUE(LnnGetNodeKeyInfo(LOCAL_NETWORKID, i, info, BUF_LEN) == SOFTBUS_OK);
209 }
210 for (i = 0; i < KEY_MAX_INDEX; i++) {
211 LnnGetNodeKeyInfo(REMOTE_NETWORKID, i, info, BUF_LEN);
212 }
213 LnnDeinitNetLedger();
214 }
215
216 /*
217 * @tc.name: LNN_NET_LEDGER_Test_002
218 * @tc.desc: lnn net ledger function test
219 * @tc.type: FUNC
220 * @tc.require:
221 */
222 HWTEST_F(NetLedgerCommonTest, LNN_NET_LEDGER_Test_002, TestSize.Level1)
223 {
224 EXPECT_TRUE(LnnInitNetLedger() == SOFTBUS_OK);
225 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_NETWORKID, LOCAL_NETWORKID) == SOFTBUS_OK);
226 EXPECT_TRUE(LnnSetNodeDataChangeFlag(nullptr, DATA_CHANGE_FLAG) == SOFTBUS_ERR);
227 EXPECT_TRUE(LnnSetNodeDataChangeFlag(LOCAL_NETWORKID, DATA_CHANGE_FLAG) == SOFTBUS_OK);
228 EXPECT_TRUE(LnnSetNodeDataChangeFlag(REMOTE_NETWORKID, DATA_CHANGE_FLAG) == SOFTBUS_ERR);
229 LnnDeinitNetLedger();
230 }
231
232 /*
233 * @tc.name: LNN_NET_LEDGER_Test_003
234 * @tc.desc: lnn net ledger function test
235 * @tc.type: FUNC
236 * @tc.require:
237 */
238 HWTEST_F(NetLedgerCommonTest, LNN_NET_LEDGER_Test_003, TestSize.Level1)
239 {
240 static int32_t nodeKeyInfoLenTable[] = {
241 UDID_BUF_LEN,
242 UUID_BUF_LEN,
243 UDID_BUF_LEN,
244 MAC_LEN,
245 IP_LEN,
246 DEVICE_NAME_BUF_LEN,
247 LNN_COMMON_LEN,
248 LNN_COMMON_LEN,
249 SOFTBUS_ERR,
250 DATA_CHANGE_FLAG_BUF_LEN,
251 SOFTBUS_ERR
252 };
253 EXPECT_TRUE(LnnInitNetLedger() == SOFTBUS_OK);
254 for (int32_t i = 0; i < KEY_MAX_INDEX; i++) {
255 EXPECT_TRUE(LnnGetNodeKeyInfoLen(i) == nodeKeyInfoLenTable[i]);
256 }
257 LnnDeinitNetLedger();
258 }
259
260 /*
261 * @tc.name: LNN_NET_LEDGER_Test_004
262 * @tc.desc: lnn net ledger function test
263 * @tc.type: FUNC
264 * @tc.require:
265 */
266 HWTEST_F(NetLedgerCommonTest, LNN_NET_LEDGER_Test_004, TestSize.Level1)
267 {
268 EXPECT_TRUE(LnnInitNetLedger() == SOFTBUS_OK);
269 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_DEV_UDID, LOCAL_UDID) == SOFTBUS_OK);
270 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_NETWORKID, LOCAL_NETWORKID) == SOFTBUS_OK);
271 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_UUID, LOCAL_UUID) == SOFTBUS_OK);
272 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_BT_MAC, LOCAL_BT_MAC) == SOFTBUS_OK);
273 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_WLAN_IP, LOCAL_WLAN_IP) == SOFTBUS_OK);
274 EXPECT_TRUE(LnnSetLocalNumInfo(NUM_KEY_NET_CAP, 1 << BIT_BR) == SOFTBUS_OK);
275 NodeBasicInfo nodeInfo;
276 (void)memset_s(&nodeInfo, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
277 (void)strcpy_s(nodeInfo.deviceName, DEVICE_NAME_BUF_LEN, NODE_DEVICE_NAME);
278 (void)strcpy_s(nodeInfo.networkId, NETWORK_ID_BUF_LEN, LOCAL_NETWORKID);
279 SoftBusDumpBusCenterPrintInfo(DEFAULT_FD, nullptr);
280 SoftBusDumpBusCenterPrintInfo(DEFAULT_FD, &nodeInfo);
281 LnnDeinitNetLedger();
282 }
283 } // namespace OHOS