1 /*
2 * Copyright (c) 2022-2023 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
18 #include "bus_center_manager.h"
19 #include "bus_center_mock.h"
20 #include "disc_manager_mock.h"
21 #include "lnn_coap_discovery_impl.c"
22 #include "lnn_coap_discovery_impl.h"
23 #include "lnn_discovery_manager.c"
24 #include "lnn_discovery_manager.h"
25 #include "lnn_hichain_mock.h"
26 #include "softbus_error_code.h"
27
28 namespace OHOS {
29 using namespace testing;
30 using namespace testing::ext;
31 const uint16_t TEST_PORT = 1234;
32
33 class LNNDiscoveryInterfaceTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp();
38 void TearDown();
39 };
40
SetUpTestCase()41 void LNNDiscoveryInterfaceTest::SetUpTestCase() { }
42
TearDownTestCase()43 void LNNDiscoveryInterfaceTest::TearDownTestCase() { }
44
SetUp()45 void LNNDiscoveryInterfaceTest::SetUp() { }
46
TearDown()47 void LNNDiscoveryInterfaceTest::TearDown() { }
48
OnRefreshDeviceFoundTest(const char * pkgName,const DeviceInfo * device,const InnerDeviceInfoAddtions * additions)49 static int32_t OnRefreshDeviceFoundTest(
50 const char *pkgName, const DeviceInfo *device, const InnerDeviceInfoAddtions *additions)
51 {
52 return SOFTBUS_OK;
53 }
54
55 static IServerDiscInnerCallback g_discInnerCb = {
56 .OnServerDeviceFound = OnRefreshDeviceFoundTest,
57 };
58
LnnCoapTest(void)59 static int32_t LnnCoapTest(void)
60 {
61 return SOFTBUS_INVALID_PARAM;
62 }
63
LnnCoapFuncTest(void)64 static int32_t LnnCoapFuncTest(void)
65 {
66 return SOFTBUS_OK;
67 }
68
69 /*
70 * @tc.name: LNN_PUBLISH_SERVICE_TEST_001
71 * @tc.desc: device found test
72 * @tc.type: FUNC
73 * @tc.require:
74 */
75 HWTEST_F(LNNDiscoveryInterfaceTest, LNN_PUBLISH_SERVICE_TEST_001, TestSize.Level1)
76 {
77 DeviceInfo device;
78 InnerDeviceInfoAddtions additions;
79
80 (void)memset_s(&device, sizeof(DeviceInfo), 0, sizeof(DeviceInfo));
81 (void)memset_s(&additions, sizeof(InnerDeviceInfoAddtions), 0, sizeof(InnerDeviceInfoAddtions));
82 BusCenterMock busCenterMock;
83 busCenterMock.SetupSuccessStub();
84 DeviceFound(nullptr, &additions);
85 DeviceFound(&device, &additions);
86 device.addr[0].type = CONNECTION_ADDR_WLAN;
87 DeviceFound(&device, &additions);
88 device.addr[0].type = CONNECTION_ADDR_ETH;
89 DeviceFound(&device, &additions);
90 device.addr[0].type = CONNECTION_ADDR_BR;
91 DeviceFound(&device, &additions);
92 device.addr[0].info.ip.port = 22;
93 DeviceFound(&device, &additions);
94
95 const char *pkgName = "testpkgName";
96 PublishInfo info;
97 bool isInnerRequest = false;
98 DiscManagerInterfaceMock discMock;
99 (void)memset_s(&info, sizeof(PublishInfo), 0, sizeof(PublishInfo));
100 EXPECT_CALL(discMock, DiscPublishService).WillRepeatedly(Return(SOFTBUS_DISCOVER_MANAGER_NOT_INIT));
101 int32_t ret = LnnPublishService(pkgName, &info, isInnerRequest, 0);
102 EXPECT_EQ(ret, SOFTBUS_DISCOVER_MANAGER_NOT_INIT);
103 }
104
105 /*
106 * @tc.name: LNN_PUBLISH_SERVICE_TEST_002
107 * @tc.desc: lnn publish service test
108 * @tc.type: FUNC
109 * @tc.require:
110 */
111 HWTEST_F(LNNDiscoveryInterfaceTest, LNN_PUBLISH_SERVICE_TEST_002, TestSize.Level1)
112 {
113 const char *pkgName = "testpkgName";
114 PublishInfo info;
115 bool isInnerRequest = false;
116 DiscManagerInterfaceMock discMock;
117 int32_t ret = 0;
118
119 (void)memset_s(&info, sizeof(PublishInfo), 0, sizeof(PublishInfo));
120 EXPECT_CALL(discMock, DiscPublishService).WillRepeatedly(Return(SOFTBUS_DISCOVER_MANAGER_NOT_INIT));
121 ret = LnnPublishService(pkgName, &info, isInnerRequest, 0);
122 EXPECT_EQ(ret, SOFTBUS_DISCOVER_MANAGER_NOT_INIT);
123 EXPECT_CALL(discMock, DiscPublishService).WillRepeatedly(Return(SOFTBUS_OK));
124 ret = LnnPublishService(pkgName, &info, isInnerRequest, 0);
125 EXPECT_EQ(ret, SOFTBUS_OK);
126 isInnerRequest = true;
127 EXPECT_CALL(discMock, DiscStartScan).WillRepeatedly(Return(SOFTBUS_DISCOVER_MANAGER_NOT_INIT));
128 ret = LnnPublishService(pkgName, &info, isInnerRequest, 0);
129 EXPECT_EQ(ret, SOFTBUS_DISCOVER_MANAGER_NOT_INIT);
130 EXPECT_CALL(discMock, DiscStartScan).WillRepeatedly(Return(SOFTBUS_OK));
131 ret = LnnPublishService(pkgName, &info, isInnerRequest, 0);
132 EXPECT_EQ(ret, SOFTBUS_OK);
133 }
134
135 /*
136 * @tc.name: LNN_UNPUBLISH_SERVICE_TEST_001
137 * @tc.desc: lnn unpublish service test
138 * @tc.type: FUNC
139 * @tc.require:
140 */
141 HWTEST_F(LNNDiscoveryInterfaceTest, LNN_UNPUBLISH_SERVICE_TEST_001, TestSize.Level1)
142 {
143 const char *pkgName = "testpkgName";
144 int32_t publishId = 0;
145 bool isInnerRequest = false;
146 DiscManagerInterfaceMock discMock;
147 int32_t ret = 0;
148
149 EXPECT_CALL(discMock, DiscUnPublishService).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
150 ret = LnnUnPublishService(pkgName, publishId, isInnerRequest, 0);
151 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_STOP_PUBLISH_FAIL);
152 EXPECT_CALL(discMock, DiscUnPublishService).WillRepeatedly(Return(SOFTBUS_OK));
153 ret = LnnUnPublishService(pkgName, publishId, isInnerRequest, 0);
154 EXPECT_EQ(ret, SOFTBUS_OK);
155 isInnerRequest = true;
156 EXPECT_CALL(discMock, DiscUnpublish).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
157 ret = LnnUnPublishService(pkgName, publishId, isInnerRequest, 0);
158 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_STOP_PUBLISH_FAIL);
159 EXPECT_CALL(discMock, DiscUnpublish).WillRepeatedly(Return(SOFTBUS_OK));
160 ret = LnnUnPublishService(pkgName, publishId, isInnerRequest, 0);
161 EXPECT_EQ(ret, SOFTBUS_OK);
162 }
163
164 /*
165 * @tc.name: LNN_START_DISC_DEVICE_TEST_001
166 * @tc.desc: lnn start disc device test
167 * @tc.type: FUNC
168 * @tc.require:
169 */
170 HWTEST_F(LNNDiscoveryInterfaceTest, LNN_START_DISC_DEVICE_TEST_001, TestSize.Level1)
171 {
172 const char *pkgName = "testpkgName";
173 SubscribeInfo info;
174 bool isInnerRequest = false;
175 DiscManagerInterfaceMock discMock;
176 int32_t ret = 0;
177
178 InnerCallback cb = {
179 .serverCb = g_discInnerCb,
180 };
181 (void)memset_s(&info, sizeof(SubscribeInfo), 0, sizeof(SubscribeInfo));
182 EXPECT_CALL(discMock, DiscStartDiscovery).WillRepeatedly(Return(SOFTBUS_DISCOVER_MANAGER_INNERFUNCTION_FAIL));
183 ret = LnnStartDiscDevice(pkgName, &info, &cb, isInnerRequest, 0);
184 EXPECT_EQ(ret, SOFTBUS_DISCOVER_MANAGER_INNERFUNCTION_FAIL);
185 EXPECT_CALL(discMock, DiscStartDiscovery).WillRepeatedly(Return(SOFTBUS_OK));
186 ret = LnnStartDiscDevice(pkgName, &info, &cb, isInnerRequest, 0);
187 EXPECT_EQ(ret, SOFTBUS_OK);
188 isInnerRequest = true;
189 EXPECT_CALL(discMock, DiscSetDiscoverCallback).WillRepeatedly(Return(SOFTBUS_DISCOVER_MANAGER_ITEM_NOT_CREATE));
190 ret = LnnStartDiscDevice(pkgName, &info, &cb, isInnerRequest, 0);
191 EXPECT_EQ(ret, SOFTBUS_DISCOVER_MANAGER_ITEM_NOT_CREATE);
192 EXPECT_CALL(discMock, DiscSetDiscoverCallback).WillRepeatedly(Return(SOFTBUS_OK));
193 EXPECT_CALL(discMock, DiscStartAdvertise).WillRepeatedly(Return(SOFTBUS_DISCOVER_MANAGER_INNERFUNCTION_FAIL));
194 ret = LnnStartDiscDevice(pkgName, &info, &cb, isInnerRequest, 0);
195 EXPECT_EQ(ret, SOFTBUS_DISCOVER_MANAGER_INNERFUNCTION_FAIL);
196 EXPECT_CALL(discMock, DiscSetDiscoverCallback).WillRepeatedly(Return(SOFTBUS_OK));
197 EXPECT_CALL(discMock, DiscStartAdvertise).WillRepeatedly(Return(SOFTBUS_OK));
198 ret = LnnStartDiscDevice(pkgName, &info, &cb, isInnerRequest, 0);
199 EXPECT_EQ(ret, SOFTBUS_OK);
200 }
201
202 /*
203 * @tc.name: LNN_STOP_DISC_DEVICE_TEST_001
204 * @tc.desc: lnn stop disc device test
205 * @tc.type: FUNC
206 * @tc.require:
207 */
208 HWTEST_F(LNNDiscoveryInterfaceTest, LNN_STOP_DISC_DEVICE_TEST_001, TestSize.Level1)
209 {
210 const char *pkgName = "testpkgName";
211 int32_t subscribeId = 0;
212 bool isInnerRequest = false;
213 DiscManagerInterfaceMock discMock;
214 int32_t ret = 0;
215
216 EXPECT_CALL(discMock, DiscStopDiscovery).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
217 ret = LnnStopDiscDevice(pkgName, subscribeId, isInnerRequest, 0);
218 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_STOP_DISCOVER_FAIL);
219 EXPECT_CALL(discMock, DiscStopDiscovery).WillRepeatedly(Return(SOFTBUS_OK));
220 ret = LnnStopDiscDevice(pkgName, subscribeId, isInnerRequest, 0);
221 EXPECT_EQ(ret, SOFTBUS_OK);
222 isInnerRequest = true;
223 EXPECT_CALL(discMock, DiscStopAdvertise).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
224 ret = LnnStopDiscDevice(pkgName, subscribeId, isInnerRequest, 0);
225 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_STOP_DISCOVER_FAIL);
226 EXPECT_CALL(discMock, DiscStopAdvertise).WillRepeatedly(Return(SOFTBUS_OK));
227 ret = LnnStopDiscDevice(pkgName, subscribeId, isInnerRequest, 0);
228 EXPECT_EQ(ret, SOFTBUS_OK);
229 }
230
231 /*
232 * @tc.name: LNN_START_PUBLISH_TEST_001
233 * @tc.desc: lnn start publish test
234 * @tc.type: FUNC
235 * @tc.require:
236 */
237 HWTEST_F(LNNDiscoveryInterfaceTest, LNN_START_PUBLISH_TEST_001, TestSize.Level1)
238 {
239 g_discoveryImpl[0].StopPublishImpl = nullptr;
240 LnnStopPublish();
241 g_discoveryImpl[0].StopPublishImpl = LnnCoapTest;
242 LnnStopPublish();
243 g_discoveryImpl[0].StopPublishImpl = LnnCoapFuncTest;
244 LnnStopPublish();
245
246 g_discoveryImpl[0].StartPublishImpl = nullptr;
247 int32_t ret = LnnStartPublish();
248 EXPECT_EQ(ret, SOFTBUS_OK);
249 g_discoveryImpl[0].StartPublishImpl = LnnCoapTest;
250 ret = LnnStartPublish();
251 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL);
252 g_discoveryImpl[0].StartPublishImpl = LnnCoapFuncTest;
253 ret = LnnStartPublish();
254 EXPECT_EQ(ret, SOFTBUS_OK);
255 }
256
257 /*
258 * @tc.name: LNN_START_DISCOVERY_TEST_001
259 * @tc.desc: lnn start discovery test
260 * @tc.type: FUNC
261 * @tc.require:
262 */
263 HWTEST_F(LNNDiscoveryInterfaceTest, LNN_START_DISCOVERY_TEST_001, TestSize.Level1)
264 {
265 g_discoveryImpl[0].StopDiscoveryImpl = nullptr;
266 LnnStopDiscovery();
267 g_discoveryImpl[0].StopDiscoveryImpl = LnnCoapTest;
268 LnnStopDiscovery();
269 g_discoveryImpl[0].StopDiscoveryImpl = LnnCoapFuncTest;
270 LnnStopDiscovery();
271
272 g_discoveryImpl[0].StartDiscoveryImpl = nullptr;
273 int32_t ret = LnnStartDiscovery();
274 EXPECT_EQ(ret, SOFTBUS_OK);
275 g_discoveryImpl[0].StartDiscoveryImpl = LnnCoapTest;
276 ret = LnnStartDiscovery();
277 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_DISCOVER_FAIL);
278 g_discoveryImpl[0].StartDiscoveryImpl = LnnCoapFuncTest;
279 ret = LnnStartDiscovery();
280 EXPECT_EQ(ret, SOFTBUS_OK);
281 }
282
283 /*
284 * @tc.name: LNN_INIT_COAP_DISCOVERY_TEST_001
285 * @tc.desc: lnn init coap discovery test
286 * @tc.type: FUNC
287 * @tc.require:
288 */
289 HWTEST_F(LNNDiscoveryInterfaceTest, LNN_INIT_COAP_DISCOVERY_TEST_001, TestSize.Level1)
290 {
291 int32_t ret = LnnInitCoapDiscovery(nullptr);
292 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
293 }
294
295 /*
296 * @tc.name: LNN_INIT_COAP_DISCOVERY_TEST_002
297 * @tc.desc: lnn init coap discovery test
298 * @tc.type: FUNC
299 * @tc.require:
300 */
301 HWTEST_F(LNNDiscoveryInterfaceTest, LNN_INIT_COAP_DISCOVERY_TEST_002, TestSize.Level1)
302 {
303 LnnDiscoveryImplCallback callback;
304 int32_t ret = LnnInitCoapDiscovery(&callback);
305 EXPECT_EQ(ret, SOFTBUS_OK);
306 }
307
308 /*
309 * @tc.name: LNN_START_COAP_DISCOVERY_TEST_001
310 * @tc.desc: lnn start coap discovery test
311 * @tc.type: FUNC
312 * @tc.require:
313 */
314 HWTEST_F(LNNDiscoveryInterfaceTest, LNN_START_COAP_DISCOVERY_TEST_001, TestSize.Level1)
315 {
316 DiscManagerInterfaceMock discMock;
317 int32_t ret;
318 EXPECT_CALL(discMock, DiscSetDiscoverCallback).WillOnce(Return(SOFTBUS_INVALID_PARAM));
319 ret = LnnStartCoapDiscovery();
320 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
321 EXPECT_CALL(discMock, DiscSetDiscoverCallback).WillOnce(Return(SOFTBUS_OK));
322 EXPECT_CALL(discMock, DiscStartAdvertise).WillOnce(Return(SOFTBUS_INVALID_PARAM));
323 ret = LnnStartCoapDiscovery();
324 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
325 EXPECT_CALL(discMock, DiscSetDiscoverCallback).WillOnce(Return(SOFTBUS_OK));
326 EXPECT_CALL(discMock, DiscStartAdvertise).WillOnce(Return(SOFTBUS_OK));
327 ret = LnnStartCoapDiscovery();
328 EXPECT_EQ(ret, SOFTBUS_OK);
329 EXPECT_CALL(discMock, DiscStopAdvertise).WillOnce(Return(SOFTBUS_INVALID_PARAM));
330 ret = LnnStopCoapDiscovery();
331 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_STOP_DISCOVER_FAIL);
332 EXPECT_CALL(discMock, DiscStopAdvertise).WillOnce(Return(SOFTBUS_OK));
333 ret = LnnStopCoapDiscovery();
334 EXPECT_EQ(ret, SOFTBUS_OK);
335 }
336
337 /*
338 * @tc.name: LNN_START_COAP_PUBLISH_TEST_001
339 * @tc.desc: lnn start coap publish test
340 * @tc.type: FUNC
341 * @tc.require:
342 */
343 HWTEST_F(LNNDiscoveryInterfaceTest, LNN_START_COAP_PUBLISH_TEST_001, TestSize.Level1)
344 {
345 DiscManagerInterfaceMock discMock;
346 int32_t ret;
347 EXPECT_CALL(discMock, DiscStartScan).WillOnce(Return(SOFTBUS_INVALID_PARAM));
348 ret = LnnStartCoapPublish();
349 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
350 EXPECT_CALL(discMock, DiscStartScan).WillOnce(Return(SOFTBUS_OK));
351 ret = LnnStartCoapPublish();
352 EXPECT_EQ(ret, SOFTBUS_OK);
353 EXPECT_CALL(discMock, DiscUnpublish).WillOnce(Return(SOFTBUS_INVALID_PARAM));
354 ret = LnnStopCoapPublish();
355 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_STOP_PUBLISH_FAIL);
356 EXPECT_CALL(discMock, DiscUnpublish).WillOnce(Return(SOFTBUS_OK));
357 ret = LnnStopCoapPublish();
358 EXPECT_EQ(ret, SOFTBUS_OK);
359 }
360
361 /*
362 * @tc.name: GET_CONNECT_DEVICE_INFO_TEST_001
363 * @tc.desc: get connect device info test
364 * @tc.type: FUNC
365 * @tc.require:
366 */
367 HWTEST_F(LNNDiscoveryInterfaceTest, GET_CONNECT_DEVICE_INFO_TEST_001, TestSize.Level1)
368 {
369 DeviceInfo devInfo;
370 ConnectionAddr addr;
371 int32_t ret = GetConnectDeviceInfo(&devInfo, &addr);
372 EXPECT_EQ(ret, SOFTBUS_OK);
373 }
374
375 /*
376 * @tc.name: LNN_CHECK_DISCOVERY_DEVICE_TEST_001
377 * @tc.desc: lnn check discovery device test
378 * @tc.type: FUNC
379 * @tc.require:
380 */
381 HWTEST_F(LNNDiscoveryInterfaceTest, LNN_CHECK_DISCOVERY_DEVICE_TEST_001, TestSize.Level1)
382 {
383 DeviceInfo devInfo;
384 devInfo.addr[0].type = CONNECTION_ADDR_BR;
385 int32_t ret = LnnCheckDiscoveryDeviceInfo(&devInfo);
386 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
387 devInfo.addr[0].type = CONNECTION_ADDR_BLE;
388 ret = LnnCheckDiscoveryDeviceInfo(&devInfo);
389 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
390 devInfo.addr[0].type = CONNECTION_ADDR_SESSION;
391 ret = LnnCheckDiscoveryDeviceInfo(&devInfo);
392 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
393 devInfo.addr[0].type = CONNECTION_ADDR_MAX;
394 ret = LnnCheckDiscoveryDeviceInfo(&devInfo);
395 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
396 devInfo.addr[0].type = CONNECTION_ADDR_WLAN;
397 devInfo.addr[0].info.ip.port = 0;
398 ret = LnnCheckDiscoveryDeviceInfo(&devInfo);
399 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
400 devInfo.addr[0].type = CONNECTION_ADDR_ETH;
401 devInfo.addr[0].info.ip.port = 0;
402 ret = LnnCheckDiscoveryDeviceInfo(&devInfo);
403 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
404 }
405
406 /*
407 * @tc.name: LNN_CHECK_DISCOVERY_DEVICE_TEST_002
408 * @tc.desc: lnn check discovery device test
409 * @tc.type: FUNC
410 * @tc.require:
411 */
412 HWTEST_F(LNNDiscoveryInterfaceTest, LNN_CHECK_DISCOVERY_DEVICE_TEST_002, TestSize.Level1)
413 {
414 DeviceInfo devInfo;
415 devInfo.addr[0].type = CONNECTION_ADDR_WLAN;
416 devInfo.addr[0].info.ip.port = TEST_PORT;
417 int32_t ret = LnnCheckDiscoveryDeviceInfo(&devInfo);
418 EXPECT_EQ(ret, SOFTBUS_OK);
419 }
420 } // namespace OHOS
421