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 "auth_interface.h"
23 #include "bus_center_manager.h"
24 #include "lnn_decision_db.h"
25 #include "lnn_decision_db.c"
26 #include "lnn_distributed_net_ledger.h"
27 #include "lnn_event_monitor.h"
28 #include "lnn_local_net_ledger.h"
29 #include "lnn_log.h"
30 #include "lnn_network_manager.h"
31 #include "lnn_node_info.h"
32
33 #include "softbus_adapter_mem.h"
34 #include "softbus_errcode.h"
35 #include "softbus_conn_interface.h"
36 #include "softbus_utils.h"
37
38 namespace OHOS {
39 using namespace testing::ext;
40 constexpr uint32_t TEST_DATA_LEN = 10;
41 constexpr uint8_t DEFAULT_SIZE = 5;
42 constexpr char NODE1_UDID[] = "123456ABCDEF";
43 constexpr char NODE2_UDID[] = "123456ABCDEG";
44
45 class NetLedgerTest : public testing::Test {
46 public:
47 static void SetUpTestCase();
48 static void TearDownTestCase();
49 void SetUp();
50 void TearDown();
51 };
52
SetUpTestCase()53 void NetLedgerTest::SetUpTestCase()
54 {
55 }
56
TearDownTestCase()57 void NetLedgerTest::TearDownTestCase()
58 {
59 }
60
SetUp()61 void NetLedgerTest::SetUp()
62 {
63 int32_t ret = LnnInitLocalLedger();
64 EXPECT_TRUE(ret == SOFTBUS_OK);
65 ret = LnnInitDistributedLedger();
66 EXPECT_TRUE(ret == SOFTBUS_OK);
67 LNN_LOGI(LNN_TEST, "NetLedgerTest start");
68 }
69
TearDown()70 void NetLedgerTest::TearDown()
71 {
72 LnnDeinitLocalLedger();
73 LnnDeinitDistributedLedger();
74 }
75
76 /*
77 * @tc.name: AUTH_TYPE_VALUE_SET_CLEAR_Test_001
78 * @tc.desc: auth type value set and clear test
79 * @tc.type: FUNC
80 * @tc.require:
81 */
82 HWTEST_F(NetLedgerTest, AUTH_TYPE_VALUE_SET_CLEAR_Test_001, TestSize.Level1)
83 {
84 int32_t ret;
85 uint32_t authType = 0;
86 uint32_t *authTypeValue = nullptr;
87
88 ret = LnnSetAuthTypeValue(authTypeValue, ONLINE_HICHAIN);
89 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
90 ret = LnnClearAuthTypeValue(authTypeValue, ONLINE_HICHAIN);
91 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
92
93 authTypeValue = &authType;
94 ret = LnnSetAuthTypeValue(authTypeValue, AUTH_TYPE_BUTT);
95 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
96 ret = LnnClearAuthTypeValue(authTypeValue, AUTH_TYPE_BUTT);
97 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
98
99 ret = LnnSetAuthTypeValue(authTypeValue, ONLINE_METANODE);
100 EXPECT_EQ(ret, SOFTBUS_OK);
101 ret = LnnClearAuthTypeValue(authTypeValue, ONLINE_HICHAIN);
102 EXPECT_EQ(ret, SOFTBUS_OK);
103 }
104
105 /*
106 * @tc.name: BUILD_TRUSTED_DEV_INFO_RECORD_Test_001
107 * @tc.desc: build trusted dev info record test
108 * @tc.type: FUNC
109 * @tc.require:
110 */
111 HWTEST_F(NetLedgerTest, BUILD_TRUSTED_DEV_INFO_RECORD_Test_001, TestSize.Level1)
112 {
113 int32_t ret;
114 const char *udid = "testdata";
115 TrustedDevInfoRecord record;
116
117 (void)memset_s(&record, sizeof(TrustedDevInfoRecord), 0, sizeof(TrustedDevInfoRecord));
118 ret = BuildTrustedDevInfoRecord(udid, &record);
119 EXPECT_EQ(ret, SOFTBUS_OK);
120
121 udid = nullptr;
122 ret = BuildTrustedDevInfoRecord(udid, &record);
123 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
124 }
125
126 /*
127 * @tc.name: LNN_GET_TRUSTED_DEV_INFO_FROM_DB_Test_001
128 * @tc.desc: lnn get trusted dev info from db test
129 * @tc.type: FUNC
130 * @tc.require:
131 */
132 HWTEST_F(NetLedgerTest, LNN_GET_TRUSTED_DEV_INFO_FROM_DB_Test_001, TestSize.Level1)
133 {
134 uint32_t num = 0;
135 int32_t ret;
136
137 char *udidArray = new char[TEST_DATA_LEN];
138 ASSERT_NE(udidArray, nullptr);
139 ret = LnnGetTrustedDevInfoFromDb(&udidArray, &num);
140 EXPECT_EQ(ret, SOFTBUS_OK);
141 delete[] udidArray;
142 }
143
144 /*
145 * @tc.name: DL_GET_Test_001
146 * @tc.desc: Dl Get Auth test
147 * @tc.type: FUNC
148 * @tc.require:
149 */
150 HWTEST_F(NetLedgerTest, DL_GET_Test_001, TestSize.Level1)
151 {
152 char networkId[DEFAULT_SIZE] = "1234";
153 int32_t info = 1234;
154 EXPECT_TRUE(LnnGetRemoteNumInfo(nullptr, NUM_KEY_SESSION_PORT, &info) == SOFTBUS_INVALID_PARAM);
155 EXPECT_TRUE(LnnGetRemoteNumInfo(networkId, STRING_KEY_END, &info) == SOFTBUS_INVALID_PARAM);
156 EXPECT_TRUE(LnnGetRemoteNumInfo(networkId, NUM_KEY_END, &info) == SOFTBUS_INVALID_PARAM);
157 EXPECT_TRUE(LnnGetRemoteNumInfo(networkId, NUM_KEY_END, nullptr) == SOFTBUS_INVALID_PARAM);
158 EXPECT_TRUE(LnnGetRemoteNumInfo(networkId, NUM_KEY_AUTH_PORT, &info) != SOFTBUS_OK);
159 }
160
161 /*
162 * @tc.name: LNN_ADD_META_INFO_Test_001
163 * @tc.desc: Lnn Add Meta Info test
164 * @tc.type: FUNC
165 * @tc.require:
166 */
167 HWTEST_F(NetLedgerTest, LNN_ADD_META_INFO_Test_001, TestSize.Level1)
168 {
169 NodeInfo info;
170 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
171 EXPECT_TRUE(LnnAddMetaInfo(&info) == SOFTBUS_OK);
172 }
173
174 /*
175 * @tc.name: LNN_DELETE_META_INFO_Test_001
176 * @tc.desc: Lnn Delete Meta Info test
177 * @tc.type: FUNC
178 * @tc.require:
179 */
180 HWTEST_F(NetLedgerTest, LNN_DELETE_META_INFO_Test_001, TestSize.Level1)
181 {
182 char udid[DEFAULT_SIZE] = "1234";
183 AuthLinkType type = AUTH_LINK_TYPE_WIFI;
184 EXPECT_TRUE(LnnDeleteMetaInfo(udid, type) != SOFTBUS_OK);
185 }
186
187 /*
188 * @tc.name: GET_ALL_ONLINE_AND_META_NODE_INFO_Test_001
189 * @tc.desc: Get All Online And Meta Node Info test
190 * @tc.type: FUNC
191 * @tc.require:
192 */
193 HWTEST_F(NetLedgerTest, GET_ALL_ONLINE_AND_META_NODE_INFO_Test_001, TestSize.Level1)
194 {
195 NodeBasicInfo base;
196 NodeBasicInfo *info = nullptr;
197 int32_t infoNum = 0;
198 EXPECT_TRUE(LnnGetAllOnlineAndMetaNodeInfo(nullptr, &infoNum) == SOFTBUS_INVALID_PARAM);
199 info = &base;
200 (void)memset_s(info, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
201 EXPECT_TRUE(LnnGetAllOnlineAndMetaNodeInfo(&info, nullptr) == SOFTBUS_INVALID_PARAM);
202 EXPECT_TRUE(LnnGetAllOnlineAndMetaNodeInfo(&info, &infoNum) == SOFTBUS_OK);
203 SoftBusFree(info);
204 info = nullptr;
205 infoNum = DEFAULT_SIZE;
206 EXPECT_TRUE(LnnGetAllOnlineAndMetaNodeInfo(&info, &infoNum) == SOFTBUS_OK);
207 SoftBusFree(info);
208 }
209
210 /*
211 * @tc.name: LNN_META_INFO_ADD_DEL_Test_001
212 * @tc.desc: lnn add and del meta info test
213 * @tc.type: FUNC
214 * @tc.require:
215 */
216 HWTEST_F(NetLedgerTest, LNN_META_INFO_ADD_DEL_Test_001, TestSize.Level1)
217 {
218 int32_t ret;
219 NodeInfo info;
220
221 ret = LnnDeleteMetaInfo(NODE2_UDID, AUTH_LINK_TYPE_WIFI);
222 EXPECT_NE(ret, SOFTBUS_OK);
223 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
224 LnnSetDeviceUdid(&info, NODE1_UDID);
225 info.metaInfo.metaDiscType = AUTH_LINK_TYPE_WIFI;
226 ret = LnnAddMetaInfo(&info);
227 EXPECT_EQ(ret, SOFTBUS_OK);
228 ret = LnnDeleteMetaInfo(NODE1_UDID, AUTH_LINK_TYPE_WIFI);
229 EXPECT_EQ(ret, SOFTBUS_OK);
230 ret = LnnDeleteMetaInfo(NODE1_UDID, AUTH_LINK_TYPE_WIFI);
231 EXPECT_EQ(ret, SOFTBUS_OK);
232 ret = LnnDeleteMetaInfo(NODE1_UDID, AUTH_LINK_TYPE_WIFI);
233 EXPECT_EQ(ret, SOFTBUS_OK);
234 }
235
236 /*
237 * @tc.name: LNN_GET_REMOTE_NUM16_INFO_Test_001
238 * @tc.desc: lnn get remote num16 info test
239 * @tc.type: FUNC
240 * @tc.require:
241 */
242 HWTEST_F(NetLedgerTest, LNN_GET_REMOTE_NUM16_INFO_Test_001, TestSize.Level1)
243 {
244 int32_t ret;
245 int16_t info1 = 0;
246 int16_t *info2 = nullptr;
247 constexpr char *networkId = nullptr;
248
249 ret = LnnGetRemoteNum16Info(NODE1_UDID, NUM_KEY_META_NODE, &info1);
250 EXPECT_NE(ret, SOFTBUS_INVALID_PARAM);
251 ret = LnnGetRemoteNum16Info(networkId, NUM_KEY_META_NODE, &info1);
252 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
253 ret = LnnGetRemoteNum16Info(networkId, NUM_KEY_META_NODE, info2);
254 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
255 ret = LnnGetRemoteNum16Info(NODE1_UDID, STRING_KEY_BEGIN, &info1);
256 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
257 ret = LnnGetRemoteNum16Info(NODE1_UDID, BYTE_KEY_END, &info1);
258 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
259 }
260 } // namespace OHOS
261