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