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 <pthread.h>
18 #include <securec.h>
19
20 #include "common_list.h"
21 #include "softbus_base_listener.h"
22 #include "softbus_def.h"
23 #include "softbus_errcode.h"
24 #include "softbus_log.h"
25 #include "softbus_tcp_socket.h"
26 #include "softbus_thread_pool.h"
27 #include "softbus_utils.h"
28 #include "softbus_conn_manager.h"
29
30 using namespace testing::ext;
31
32 static const int INVALID_FD = -1;
33 static const int TEST_FD = 1;
34 static pthread_mutex_t g_isInitedLock;
35 static int g_count = 0;
36 static int g_port = 6666;
37
38 namespace OHOS {
39 class SoftbusCommonTest : public testing::Test {
40 public:
SoftbusCommonTest()41 SoftbusCommonTest()
42 {}
~SoftbusCommonTest()43 ~SoftbusCommonTest()
44 {}
45 static void SetUpTestCase(void);
46 static void TearDownTestCase(void);
47 void SetUp();
48 void TearDown();
49 };
50
ThreadPoolTask(void * arg)51 int ThreadPoolTask(void* arg)
52 {
53 pthread_mutex_lock(&g_isInitedLock);
54 g_count++;
55 pthread_mutex_unlock(&g_isInitedLock);
56 return SOFTBUS_OK;
57 }
58
SetUpTestCase(void)59 void SoftbusCommonTest::SetUpTestCase(void)
60 {
61 pthread_mutex_init(&g_isInitedLock, nullptr);
62 GTEST_LOG_(INFO) << "SoftbusCommonTestSetUp";
63 ConnServerInit();
64 }
65
TearDownTestCase(void)66 void SoftbusCommonTest::TearDownTestCase(void)
67 {
68 g_count = 0;
69 g_port++;
70 GTEST_LOG_(INFO) << "+-------------------------------------------+";
71 }
72
SetUp(void)73 void SoftbusCommonTest::SetUp(void)
74 {
75 g_count = 0;
76 }
77
TearDown(void)78 void SoftbusCommonTest::TearDown(void)
79 {
80 g_count = 0;
81 }
82
ConnectEvent(ListenerModule module,int32_t events,int32_t cfd,const ConnectOption * clientAddr)83 int32_t ConnectEvent(ListenerModule module, int32_t events, int32_t cfd, const ConnectOption *clientAddr)
84 {
85 return 0;
86 }
87
DataEvent(ListenerModule module,int32_t events,int32_t fd)88 int32_t DataEvent(ListenerModule module, int32_t events, int32_t fd)
89 {
90 return 0;
91 }
92
93 SocketAddr g_socketAddr = {
94 .addr = "127.0.0.1",
95 .port = g_port,
96 };
97
98 /*
99 * @tc.name: testBaseListener001
100 * @tc.desc: test GetSoftbusBaseListener invalid input param
101 * @tc.type: FUNC
102 * @tc.require:
103 */
104 HWTEST_F(SoftbusCommonTest, testBaseListener001, TestSize.Level1)
105 {
106 EXPECT_EQ(SOFTBUS_INVALID_PARAM, GetSoftbusBaseListener(PROXY, nullptr));
107 EXPECT_EQ(SOFTBUS_INVALID_PARAM, GetSoftbusBaseListener(AUTH, nullptr));
108 EXPECT_EQ(SOFTBUS_INVALID_PARAM, GetSoftbusBaseListener(DIRECT_CHANNEL_SERVER_WIFI, nullptr));
109 EXPECT_EQ(SOFTBUS_INVALID_PARAM, GetSoftbusBaseListener(UNUSE_BUTT, nullptr));
110 };
111
112 /*
113 * @tc.name: testBaseListener002
114 * @tc.desc: test GetSoftbusBaseListener and set
115 * @tc.type: FUNC
116 * @tc.require: I5HSOL
117 */
118 HWTEST_F(SoftbusCommonTest, testBaseListener002, TestSize.Level1)
119 {
120 int i;
121 int port = 6666;
122 for (i = PROXY; i <= LISTENER_MODULE_DYNAMIC_START; i++) {
123 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetSoftbusBaseListener(static_cast<ListenerModule>(i), nullptr));
124 }
125 SoftbusBaseListener *setListener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
126 ASSERT_TRUE(setListener != nullptr);
127 setListener->onConnectEvent = ConnectEvent;
128 setListener->onDataEvent = DataEvent;
129 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
130 SoftbusBaseListener getListener = {0};
131 LocalListenerInfo info = {
132 .type = CONNECT_TCP,
133 .socketOption = {
134 .addr = "127.0.0.1",
135 .port = port,
136 .moduleId = static_cast<ListenerModule>(i),
137 .protocol = LNN_PROTOCOL_IP
138 }
139 };
140 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(static_cast<ListenerModule>(i), setListener));
141 EXPECT_EQ(port, StartBaseListener(&info));
142 EXPECT_EQ(SOFTBUS_OK, GetSoftbusBaseListener(static_cast<ListenerModule>(i), &getListener));
143 EXPECT_EQ(setListener->onConnectEvent, getListener.onConnectEvent);
144 EXPECT_EQ(setListener->onDataEvent, getListener.onDataEvent);
145 ASSERT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(i)));
146 ++port;
147 }
148 EXPECT_EQ(SOFTBUS_NOT_FIND, SetSoftbusBaseListener(LISTENER_MODULE_DYNAMIC_START, setListener));
149 free(setListener);
150 };
151
152 /*
153 * @tc.name: testBaseListener003
154 * @tc.desc: test start stop listener
155 * @tc.type: FUNC
156 * @tc.require:
157 */
158 HWTEST_F(SoftbusCommonTest, testBaseListener003, TestSize.Level1)
159 {
160 ListenerModule module = PROXY;
161 int port = 6666;
162 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(module));
163 SoftbusBaseListener* listener = (SoftbusBaseListener*)malloc(sizeof(SoftbusBaseListener));
164 ASSERT_TRUE(listener != nullptr);
165 listener->onConnectEvent = ConnectEvent;
166 listener->onDataEvent = DataEvent;
167 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(module, listener));
168
169 LocalListenerInfo info = {
170 .type = CONNECT_TCP,
171 .socketOption = {
172 .addr = "",
173 .port = port,
174 .moduleId = module,
175 .protocol = LNN_PROTOCOL_IP
176 }
177 };
178
179 EXPECT_EQ(SOFTBUS_TCP_SOCKET_ERR, StartBaseListener(&info));
180
181 ASSERT_EQ(strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), "127.0.0.1"), EOK);
182 info.socketOption.port = -1;
183
184 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBaseListener(&info));
185 info.socketOption.port = port;
186 EXPECT_EQ(port, StartBaseListener(&info));
187 EXPECT_EQ(SOFTBUS_ERR, StartBaseListener(&info));
188 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(module));
189 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(module));
190 free(listener);
191 };
192
193 /*
194 * @tc.name: testBaseListener004
195 * @tc.desc: test start client
196 * @tc.type: FUNC
197 * @tc.require:
198 */
199 HWTEST_F(SoftbusCommonTest, testBaseListener004, TestSize.Level1)
200 {
201 ListenerModule module = DIRECT_CHANNEL_SERVER_WIFI;
202 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(module));
203 SoftbusBaseListener* listener = (SoftbusBaseListener*)malloc(sizeof(SoftbusBaseListener));
204 ASSERT_TRUE(listener != nullptr);
205 listener->onConnectEvent = ConnectEvent;
206 listener->onDataEvent = DataEvent;
207 EXPECT_EQ(SOFTBUS_OK, StartBaseClient(module));
208 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(module, listener));
209 EXPECT_EQ(SOFTBUS_ERR, StartBaseClient(module));
210 EXPECT_EQ(SOFTBUS_ERR, StartBaseClient(module));
211 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(module));
212 free(listener);
213 };
214
215 /*
216 * @tc.name: testBaseListener005
217 * @tc.desc: test set start stop listener
218 * @tc.type: FUNC
219 * @tc.require:
220 */
221 HWTEST_F(SoftbusCommonTest, testBaseListener005, TestSize.Level1)
222 {
223 int ret;
224 int module;
225 int port = 6666;
226 for (module = PROXY; module < LISTENER_MODULE_DYNAMIC_START; module++) {
227 SoftbusBaseListener* listener = (SoftbusBaseListener*)malloc(sizeof(SoftbusBaseListener));
228 if (listener == nullptr) {
229 for (int i = 0; i < module; i++) {
230 ret = StopBaseListener(static_cast<ListenerModule>(i));
231 EXPECT_EQ(SOFTBUS_OK, ret);
232 }
233 continue;
234 }
235
236 LocalListenerInfo info = {
237 .type = CONNECT_TCP,
238 .socketOption = {.addr = "127.0.0.1",
239 .port = port,
240 .moduleId = static_cast<ListenerModule>(module),
241 .protocol = LNN_PROTOCOL_IP}
242 };
243
244 listener->onConnectEvent = ConnectEvent;
245 listener->onDataEvent = DataEvent;
246 ret = SetSoftbusBaseListener(static_cast<ListenerModule>(module), listener);
247 EXPECT_EQ(SOFTBUS_OK, ret);
248 ret = StartBaseListener(&info);
249 EXPECT_EQ(port, ret);
250 free(listener);
251 }
252 for (module = PROXY; module < LISTENER_MODULE_DYNAMIC_START; module++) {
253 ret = StopBaseListener(static_cast<ListenerModule>(module));
254 EXPECT_EQ(SOFTBUS_OK, ret);
255 }
256 };
257
258 /*
259 * @tc.name: testBaseListener006
260 * @tc.desc: test Invalid trigger param
261 * @tc.type: FUNC
262 * @tc.require:
263 */
264 HWTEST_F(SoftbusCommonTest, testBaseListener006, TestSize.Level1)
265 {
266 int module;
267 int triggerType;
268 int fd = 1;
269 for (triggerType = READ_TRIGGER; triggerType <= RW_TRIGGER; triggerType++) {
270 EXPECT_EQ(SOFTBUS_NOT_FIND, AddTrigger(UNUSE_BUTT, fd, static_cast<TriggerType>(triggerType)));
271 EXPECT_EQ(SOFTBUS_NOT_FIND, DelTrigger(UNUSE_BUTT, fd, static_cast<TriggerType>(triggerType)));
272 }
273 for (module = PROXY; module < LISTENER_MODULE_DYNAMIC_START; module++) {
274 for (triggerType = READ_TRIGGER; triggerType <= RW_TRIGGER; triggerType++) {
275 EXPECT_EQ(SOFTBUS_INVALID_PARAM, AddTrigger(static_cast<ListenerModule>(module), INVALID_FD,
276 static_cast<TriggerType>(triggerType)));
277 EXPECT_EQ(SOFTBUS_INVALID_PARAM, DelTrigger(static_cast<ListenerModule>(module), INVALID_FD,
278 static_cast<TriggerType>(triggerType)));
279 }
280 }
281 };
282
283 /*
284 * @tc.name: testBaseListener007
285 * @tc.desc: test Not set baselistener
286 * @tc.type: FUNC
287 * @tc.require:
288 */
289 HWTEST_F(SoftbusCommonTest, testBaseListener007, TestSize.Level1)
290 {
291 int module;
292 int triggerType;
293 int fd = 1;
294 for (module = PROXY; module < LISTENER_MODULE_DYNAMIC_START; module++) {
295 for (triggerType = READ_TRIGGER; triggerType <= RW_TRIGGER; triggerType++) {
296 EXPECT_EQ(SOFTBUS_OK, AddTrigger(static_cast<ListenerModule>(module),
297 fd, static_cast<TriggerType>(triggerType)));
298 EXPECT_EQ(SOFTBUS_OK, DelTrigger(static_cast<ListenerModule>(module),
299 fd, static_cast<TriggerType>(triggerType)));
300 }
301 }
302 };
303
304 /*
305 * @tc.name: testBaseListener008
306 * @tc.desc: test add del trigger
307 * @tc.type: FUNC
308 * @tc.require:
309 */
310 HWTEST_F(SoftbusCommonTest, testBaseListener008, TestSize.Level1)
311 {
312 int module;
313 int triggerType;
314 int fd = 1;
315 int port = 6666;
316
317 for (module = PROXY; module < LISTENER_MODULE_DYNAMIC_START; module++) {
318 SoftbusBaseListener* listener = (SoftbusBaseListener*)malloc(sizeof(SoftbusBaseListener));
319 ASSERT_TRUE(listener != nullptr);
320 listener->onConnectEvent = ConnectEvent;
321 listener->onDataEvent = DataEvent;
322
323 LocalListenerInfo info = {
324 .type = CONNECT_TCP,
325 .socketOption = {.addr = "127.0.0.1",
326 .port = port,
327 .moduleId = static_cast<ListenerModule>(module),
328 .protocol = LNN_PROTOCOL_IP}
329 };
330 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(static_cast<ListenerModule>(module), listener));
331 EXPECT_EQ(port, StartBaseListener(&info));
332 for (triggerType = READ_TRIGGER; triggerType <= RW_TRIGGER; triggerType++) {
333 EXPECT_EQ(SOFTBUS_OK, AddTrigger(static_cast<ListenerModule>(module),
334 fd, static_cast<TriggerType>(triggerType)));
335 EXPECT_EQ(SOFTBUS_OK, AddTrigger(static_cast<ListenerModule>(module),
336 fd, static_cast<TriggerType>(triggerType)));
337 EXPECT_EQ(SOFTBUS_OK, DelTrigger(static_cast<ListenerModule>(module),
338 fd, static_cast<TriggerType>(triggerType)));
339 EXPECT_EQ(SOFTBUS_OK, DelTrigger(static_cast<ListenerModule>(module),
340 fd, static_cast<TriggerType>(triggerType)));
341 }
342 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(module)));
343 free(listener);
344 }
345 };
346
347 /*
348 * @tc.name: testBaseListener009
349 * @tc.desc: Test GetSoftbusBaseListener invalid input param SoftbusBaseListener *listener.
350 * @tc.in: Test module, Test number, Test Levels.
351 * @tc.out: NonZero
352 * @tc.type: FUNC
353 * @tc.require: The GetSoftbusBaseListener operates normally.
354 */
355 HWTEST_F(SoftbusCommonTest, testBaseListener009, TestSize.Level1)
356 {
357 EXPECT_EQ(SOFTBUS_INVALID_PARAM, GetSoftbusBaseListener(AUTH_P2P, nullptr));
358 EXPECT_EQ(SOFTBUS_INVALID_PARAM, GetSoftbusBaseListener(DIRECT_CHANNEL_SERVER_P2P, nullptr));
359 EXPECT_EQ(SOFTBUS_INVALID_PARAM, GetSoftbusBaseListener(DIRECT_CHANNEL_CLIENT, nullptr));
360 };
361
362 /*
363 * @tc.name: testBaseListener010
364 * @tc.desc: Test GetSoftbusBaseListener invalid input param ListenerModule module.
365 * @tc.in: Test module, Test number, Test Levels.
366 * @tc.out: NonZero
367 * @tc.type: FUNC
368 * @tc.require: The GetSoftbusBaseListener operates normally.
369 */
370 HWTEST_F(SoftbusCommonTest, testBaseListener010, TestSize.Level1)
371 {
372 SoftbusBaseListener getListener;
373 EXPECT_EQ(SOFTBUS_NOT_FIND, GetSoftbusBaseListener(static_cast<ListenerModule>(UNUSE_BUTT), &getListener));
374 EXPECT_EQ(SOFTBUS_NOT_FIND, GetSoftbusBaseListener(static_cast<ListenerModule>(PROXY - 1), &getListener));
375 };
376
377 /*
378 * @tc.name: testBaseListener011
379 * @tc.desc: Test SetSoftbusBaseListener invalid input param const SoftbusBaseListener *listener.
380 * @tc.in: Test module, Test number, Test Levels.
381 * @tc.out: NonZero
382 * @tc.type: FUNC
383 * @tc.require: The GetSoftbusBaseListener operates normally.
384 */
385 HWTEST_F(SoftbusCommonTest, testBaseListener011, TestSize.Level1)
386 {
387 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetSoftbusBaseListener(AUTH_P2P, nullptr));
388 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetSoftbusBaseListener(DIRECT_CHANNEL_SERVER_P2P, nullptr));
389 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetSoftbusBaseListener(DIRECT_CHANNEL_CLIENT, nullptr));
390 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetSoftbusBaseListener(PROXY, nullptr));
391 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetSoftbusBaseListener(AUTH, nullptr));
392 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetSoftbusBaseListener(DIRECT_CHANNEL_SERVER_WIFI, nullptr));
393 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetSoftbusBaseListener(UNUSE_BUTT, nullptr));
394 };
395
396 /*
397 * @tc.name: testBaseListener012
398 * @tc.desc: Test SetSoftbusBaseListener invalid input param ListenerModule module.
399 * @tc.in: Test module, Test number, Test Levels.
400 * @tc.out: NonZero
401 * @tc.type: FUNC
402 * @tc.require: The SetSoftbusBaseListener operates normally.
403 */
404 HWTEST_F(SoftbusCommonTest, testBaseListener012, TestSize.Level1)
405 {
406 SoftbusBaseListener *setListener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
407 if (setListener == nullptr) {
408 return;
409 }
410 setListener->onConnectEvent = ConnectEvent;
411 setListener->onDataEvent = DataEvent;
412 EXPECT_EQ(SOFTBUS_NOT_FIND, SetSoftbusBaseListener(static_cast<ListenerModule>(UNUSE_BUTT), setListener));
413 EXPECT_EQ(SOFTBUS_NOT_FIND, SetSoftbusBaseListener(static_cast<ListenerModule>(PROXY - 1), setListener));
414 if (setListener != nullptr) {
415 free(setListener);
416 }
417 };
418
419 /*
420 * @tc.name: testBaseListener013
421 * @tc.desc: Test setSoftbusBaseListene SOFTBUS_OK.
422 * @tc.in: Test module, Test number, Test Levels.
423 * @tc.out: Zero
424 * @tc.type: FUNC
425 * @tc.require: The SetSoftbusBaseListener operates normally.
426 */
427 HWTEST_F(SoftbusCommonTest, testBaseListener013, TestSize.Level1)
428 {
429 int i;
430 SoftbusBaseListener *setListener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
431 ASSERT_TRUE(setListener != nullptr);
432 setListener->onConnectEvent = ConnectEvent;
433 setListener->onDataEvent = DataEvent;
434 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
435 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(static_cast<ListenerModule>(i), setListener));
436 }
437 free(setListener);
438 };
439
440 /*
441 * @tc.name: testBaseListener014
442 * @tc.desc: Test GetSoftbusBaseListener SOFTBUS_ERR.
443 * @tc.in: Test module, Test number, Test Levels.
444 * @tc.out: NonZero
445 * @tc.type: FUNC
446 * @tc.require: The GetSoftbusBaseListener operates normally.
447 */
448 HWTEST_F(SoftbusCommonTest, testBaseListener014, TestSize.Level1)
449 {
450 int i;
451 SoftbusBaseListener getListener = {0};
452 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
453 EXPECT_EQ(SOFTBUS_OK, GetSoftbusBaseListener(static_cast<ListenerModule>(i), &getListener));
454 }
455 };
456
457 /*
458 * @tc.name: testBaseListener015
459 * @tc.desc: Test SetSoftbusBaseListener SOFTBUS_OK.
460 * @tc.in: Test module, Test number, Test Levels.
461 * @tc.out: Zero
462 * @tc.type: FUNC
463 * @tc.require: The SetSoftbusBaseListener operates normally.
464 */
465 HWTEST_F(SoftbusCommonTest, testBaseListener015, TestSize.Level1)
466 {
467 int i;
468 for (i = PROXY; i <= LISTENER_MODULE_DYNAMIC_START; i++) {
469 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetSoftbusBaseListener(static_cast<ListenerModule>(i), nullptr));
470 }
471 SoftbusBaseListener *setListener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
472 ASSERT_TRUE(setListener != nullptr);
473 setListener->onConnectEvent = ConnectEvent;
474 setListener->onDataEvent = DataEvent;
475 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
476 SoftbusBaseListener getListener = {0};
477 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(static_cast<ListenerModule>(i), setListener));
478 EXPECT_EQ(SOFTBUS_OK, GetSoftbusBaseListener(static_cast<ListenerModule>(i), &getListener));
479 EXPECT_EQ(setListener->onConnectEvent, getListener.onConnectEvent);
480 EXPECT_EQ(setListener->onDataEvent, getListener.onDataEvent);
481 }
482 free(setListener);
483 };
484
485 /*
486 * @tc.name: testBaseListener016
487 * @tc.desc: Test StartBaseClient invalid input param ListenerModule module.
488 * @tc.in: Test module, Test number, Test Levels.
489 * @tc.out: NonZero
490 * @tc.type: FUNC
491 * @tc.require: The StartBaseClient operates normally.
492 */
493 HWTEST_F(SoftbusCommonTest, testBaseListener016, TestSize.Level1)
494 {
495 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBaseClient(static_cast<ListenerModule>(PROXY - 1)));
496 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBaseClient(static_cast<ListenerModule>(DIRECT_CHANNEL_SERVER_WIFI + 1)));
497 };
498
499 /*
500 * @tc.name: testBaseListener017
501 * @tc.desc: Test StartBaseClient, BaseListener not set, start failed.
502 * @tc.in: Test module, Test number, Test Levels.
503 * @tc.out: NonZero
504 * @tc.type: FUNC
505 * @tc.require: The StartBaseClient operates normally.
506 */
507 HWTEST_F(SoftbusCommonTest, testBaseListener017, TestSize.Level1)
508 {
509 int i;
510 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
511 EXPECT_EQ(SOFTBUS_OK, StartBaseClient(static_cast<ListenerModule>(i)));
512 }
513 };
514
515 /*
516 * @tc.name: testBaseListener018
517 * @tc.desc: Test StartBaseClient, set BaseListener, start successfully.
518 * @tc.in: Test module, Test number, Test Levels.
519 * @tc.out: Zero
520 * @tc.type: FUNC
521 * @tc.require: The SetSoftbusBaseListener and StartBaseClient operates normally.
522 */
523 HWTEST_F(SoftbusCommonTest, testBaseListener018, TestSize.Level1)
524 {
525 int i;
526 SoftbusBaseListener *setListener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
527 ASSERT_TRUE(setListener != nullptr);
528 setListener->onConnectEvent = ConnectEvent;
529 setListener->onDataEvent = DataEvent;
530 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
531 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(static_cast<ListenerModule>(i), setListener));
532 EXPECT_EQ(SOFTBUS_ERR, StartBaseClient(static_cast<ListenerModule>(i)));
533 EXPECT_EQ(SOFTBUS_ERR, StartBaseClient(static_cast<ListenerModule>(i)));
534 }
535 free(setListener);
536 };
537
538 /*
539 * @tc.name: testBaseListener019
540 * @tc.desc: Test StartBaseClient, BaseListener set, start OK.
541 * @tc.in: Test module, Test number, Test Levels.
542 * @tc.out: Zero
543 * @tc.type: FUNC
544 * @tc.require: The StartBaseClient and SetSoftbusBaseListener operates normally.
545 */
546 HWTEST_F(SoftbusCommonTest, testBaseListener019, TestSize.Level1)
547 {
548 int i;
549 SoftbusBaseListener *setListener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
550 ASSERT_TRUE(setListener != nullptr);
551 setListener->onConnectEvent = ConnectEvent;
552 setListener->onDataEvent = DataEvent;
553 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
554 EXPECT_EQ(SOFTBUS_ERR, StartBaseClient(static_cast<ListenerModule>(i)));
555 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(static_cast<ListenerModule>(i), setListener));
556 EXPECT_EQ(SOFTBUS_ERR, StartBaseClient(static_cast<ListenerModule>(i)));
557 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(static_cast<ListenerModule>(i), setListener));
558 EXPECT_EQ(SOFTBUS_ERR, StartBaseClient(static_cast<ListenerModule>(i)));
559 }
560 free(setListener);
561 };
562
563 /*
564 * @tc.name: testBaseListener020
565 * @tc.desc: Test StartBaseListener invalid input param ListenerModule module.
566 * @tc.in: Test module, Test number, Test Levels.
567 * @tc.out: NonZero
568 * @tc.type: FUNC
569 * @tc.require: The StartBaseListener operates normally.
570 */
571 HWTEST_F(SoftbusCommonTest, testBaseListener020, TestSize.Level1)
572 {
573 LocalListenerInfo info = {
574 .type = CONNECT_TCP,
575 .socketOption = {.addr = "127.0.0.1",
576 .port = 666,
577 .moduleId = static_cast<ListenerModule>(PROXY - 1),
578 .protocol = LNN_PROTOCOL_IP}
579 };
580 EXPECT_EQ(SOFTBUS_NOT_FIND, StartBaseListener(&info));
581 info.socketOption.moduleId = static_cast<ListenerModule>(UNUSE_BUTT);
582 EXPECT_EQ(SOFTBUS_NOT_FIND, StartBaseListener(&info));
583 };
584
585 /*
586 * @tc.name: testBaseListener021
587 * @tc.desc: Test StartBaseListener invalid input param const char *ip.
588 * @tc.in: Test module, Test number, Test Levels.
589 * @tc.out: NonZero
590 * @tc.type: FUNC
591 * @tc.require: The StartBaseListener operates normally.
592 */
593 HWTEST_F(SoftbusCommonTest, testBaseListener021, TestSize.Level1)
594 {
595 LocalListenerInfo info = {
596 .type = CONNECT_TCP,
597 .socketOption = {.addr = "",
598 .port = 666,
599 .moduleId = PROXY,
600 .protocol = LNN_PROTOCOL_IP}
601 };
602 int i;
603 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
604 info.socketOption.moduleId = static_cast<ListenerModule>(i);
605 EXPECT_EQ(SOFTBUS_ERR, StartBaseListener(&info));
606 }
607 };
608
609 /*
610 * @tc.name: testBaseListener022
611 * @tc.desc: Test StartBaseListener invalid input param int32_t port < 0.
612 * @tc.in: Test module, Test number, Test Levels.
613 * @tc.out: NonZero
614 * @tc.type: FUNC
615 * @tc.require: The StartBaseListener operates normally.
616 */
617 HWTEST_F(SoftbusCommonTest, testBaseListener022, TestSize.Level1)
618 {
619 LocalListenerInfo info = {
620 .type = CONNECT_TCP,
621 .socketOption = {.addr = "127.0.0.1",
622 .port = -1,
623 .moduleId = PROXY,
624 .protocol = LNN_PROTOCOL_IP}
625 };
626 int i;
627 for (i = PROXY; i <= LISTENER_MODULE_DYNAMIC_START; i++) {
628 info.socketOption.moduleId = static_cast<ListenerModule>(i);
629 EXPECT_EQ(
630 SOFTBUS_INVALID_PARAM, StartBaseListener(&info));
631 }
632 };
633
634 /*
635 * @tc.name: testBaseListener023
636 * @tc.desc: Test StartBaseListener, BaseListener not set, start failed.
637 * @tc.in: Test module, Test number, Test Levels.
638 * @tc.out: NonZero
639 * @tc.type: FUNC
640 * @tc.require: The StartBaseListener operates normally.
641 */
642 HWTEST_F(SoftbusCommonTest, testBaseListener023, TestSize.Level1)
643 {
644 LocalListenerInfo info = {
645 .type = CONNECT_TCP,
646 .socketOption = {.addr = "127.0.0.1",
647 .port = -1,
648 .moduleId = PROXY,
649 .protocol = LNN_PROTOCOL_IP}
650 };
651 int i;
652 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
653 info.socketOption.moduleId = static_cast<ListenerModule>(i);
654 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBaseListener(&info));
655 }
656 };
657
658 /*
659 * @tc.name: testBaseListener024
660 * @tc.desc: Test StartBaseListener, set BaseListener, run successfully.
661 * @tc.in: Test module, Test number, Test Levels.
662 * @tc.out: Zero
663 * @tc.type: FUNC
664 * @tc.require: The SetSoftbusBaseListener and StartBaseListener operates normally.
665 */
666 HWTEST_F(SoftbusCommonTest, testBaseListener024, TestSize.Level1)
667 {
668 SoftbusBaseListener *setListener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
669 ASSERT_TRUE(setListener != nullptr);
670 setListener->onConnectEvent = ConnectEvent;
671 setListener->onDataEvent = DataEvent;
672
673 LocalListenerInfo info = {
674 .type = CONNECT_TCP,
675 .socketOption = {.addr = "127.0.0.1",
676 .port = 6666,
677 .moduleId = PROXY,
678 .protocol = LNN_PROTOCOL_IP}
679 };
680 for (int i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
681 info.socketOption.moduleId = static_cast<ListenerModule>(i);
682 info.socketOption.port++;
683 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(static_cast<ListenerModule>(i), setListener));
684 EXPECT_EQ(SOFTBUS_ERR, StartBaseListener(&info));
685 }
686 free(setListener);
687 };
688
689 /*
690 * @tc.name: testBaseListener025
691 * @tc.desc: Test StartBaseListener, BaseListener set, start OK.
692 * @tc.in: Test module, Test number, Test Levels.
693 * @tc.out: Zero
694 * @tc.type: FUNC
695 * @tc.require: The SetSoftbusBaseListener and StartBaseListener operates normally.
696 */
697 HWTEST_F(SoftbusCommonTest, testBaseListener025, TestSize.Level1)
698 {
699 SoftbusBaseListener *setListener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
700 ASSERT_TRUE(setListener != nullptr);
701 setListener->onConnectEvent = ConnectEvent;
702 setListener->onDataEvent = DataEvent;
703
704 LocalListenerInfo info = {
705 .type = CONNECT_TCP,
706 .socketOption = {.addr = "127.0.0.1",
707 .port = 6666,
708 .moduleId = PROXY,
709 .protocol = LNN_PROTOCOL_IP}
710 };
711
712 for (int i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
713 info.socketOption.port++;
714 info.socketOption.moduleId = static_cast<ListenerModule>(i);
715 SoftbusBaseListener getListener = {0};
716 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(static_cast<ListenerModule>(i), setListener));
717 EXPECT_EQ(SOFTBUS_ERR, StartBaseListener(&info));
718 EXPECT_EQ(SOFTBUS_OK, GetSoftbusBaseListener(static_cast<ListenerModule>(i), &getListener));
719 }
720 free(setListener);
721 };
722
723 /*
724 * @tc.name: testBaseListener026
725 * @tc.desc: Test StopBaseListener invalid input param ListenerModule module.
726 * @tc.in: Test module, Test number, Test Levels.
727 * @tc.out: NonZero
728 * @tc.type: FUNC
729 * @tc.require: The StopBaseListener operates normally.
730 */
731 HWTEST_F(SoftbusCommonTest, testBaseListener026, TestSize.Level1)
732 {
733 EXPECT_EQ(SOFTBUS_NOT_FIND, StopBaseListener(static_cast<ListenerModule>(PROXY - 1)));
734 EXPECT_EQ(SOFTBUS_NOT_FIND, StopBaseListener(static_cast<ListenerModule>(UNUSE_BUTT)));
735 };
736
737 /*
738 * @tc.name: testBaseListener027
739 * @tc.desc: Test StopBaseListener failed g_listenerList[module].info = NULL.
740 * @tc.in: Test module, Test number, Test Levels.
741 * @tc.out: NonZero
742 * @tc.type: FUNC
743 * @tc.require: The StopBaseListener operates normally.
744 */
745 HWTEST_F(SoftbusCommonTest, testBaseListener027, TestSize.Level1)
746 {
747 int i;
748 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
749 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(i)));
750 }
751 EXPECT_EQ(SOFTBUS_NOT_FIND, StopBaseListener(UNUSE_BUTT));
752 };
753
754 /*
755 * @tc.name: testBaseListener028
756 * @tc.desc: Test SetSoftbusBaseListener and get StartBaseListener and stop.
757 * @tc.in: Test module, Test number, Test Levels.
758 * @tc.out: Zero
759 * @tc.type: FUNC
760 * @tc.require: The SetSoftbusBaseListener and StopBaseListener and StartBaseListener operates normally.
761 */
762 HWTEST_F(SoftbusCommonTest, testBaseListener028, TestSize.Level1)
763 {
764 SoftbusBaseListener *setListener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
765 ASSERT_TRUE(setListener != nullptr);
766 setListener->onConnectEvent = ConnectEvent;
767 setListener->onDataEvent = DataEvent;
768
769 LocalListenerInfo info = {
770 .type = CONNECT_TCP,
771 .socketOption = {.addr = "127.0.0.1",
772 .port = 6666,
773 .moduleId = PROXY,
774 .protocol = LNN_PROTOCOL_IP}
775 };
776
777 for (int i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
778 info.socketOption.port++;
779 info.socketOption.moduleId = static_cast<ListenerModule>(i);
780 SoftbusBaseListener getListener = {0};
781 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(static_cast<ListenerModule>(i), setListener));
782 EXPECT_EQ(SOFTBUS_OK, GetSoftbusBaseListener(static_cast<ListenerModule>(i), &getListener));
783 EXPECT_EQ(setListener->onConnectEvent, getListener.onConnectEvent);
784 EXPECT_EQ(setListener->onDataEvent, getListener.onDataEvent);
785
786 EXPECT_EQ(info.socketOption.port, StartBaseListener(&info));
787 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(i)));
788 }
789 free(setListener);
790 };
791
792 /*
793 * @tc.name: testBaseListener029
794 * @tc.desc: Test SetSoftbusBaseListener and get StartBaseListener and stop and startBaseClient.
795 * @tc.in: Test module, Test number, Test Levels.
796 * @tc.out: Zero
797 * @tc.type: FUNC
798 * @tc.require: The SetSoftbusBaseListener and StartBaseClient and StartBaseListener operates normally.
799 */
800 HWTEST_F(SoftbusCommonTest, testBaseListener029, TestSize.Level1)
801 {
802 int i;
803 SoftbusBaseListener *setListener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
804 ASSERT_TRUE(setListener != nullptr);
805 setListener->onConnectEvent = ConnectEvent;
806 setListener->onDataEvent = DataEvent;
807
808 LocalListenerInfo info = {
809 .type = CONNECT_TCP,
810 .socketOption = {.addr = "127.0.0.1",
811 .port = 6666,
812 .moduleId = PROXY,
813 .protocol = LNN_PROTOCOL_IP}
814 };
815
816 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
817 SoftbusBaseListener getListener = {0};
818 info.socketOption.port++;
819 info.socketOption.moduleId = static_cast<ListenerModule>(i);
820 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(static_cast<ListenerModule>(i), setListener));
821 EXPECT_EQ(SOFTBUS_OK, GetSoftbusBaseListener(static_cast<ListenerModule>(i), &getListener));
822 EXPECT_EQ(setListener->onConnectEvent, getListener.onConnectEvent);
823 EXPECT_EQ(setListener->onDataEvent, getListener.onDataEvent);
824
825 EXPECT_EQ(info.socketOption.port, StartBaseListener(&info));
826 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(i)));
827 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(i)));
828 }
829 free(setListener);
830 };
831
832 /*
833 * @tc.name: testBaseListener030
834 * @tc.desc: Test AddTrigger DelTrigger invalid triggerType param.
835 * @tc.in: Test module, Test number, Test Levels.
836 * @tc.out: NonZero
837 * @tc.type: FUNC
838 * @tc.require: The AddTrigger and DelTrigger operates normally.
839 */
840 HWTEST_F(SoftbusCommonTest, testBaseListener030, TestSize.Level1)
841 {
842 int module;
843 int fd = 1;
844
845 LocalListenerInfo info = {
846 .type = CONNECT_TCP,
847 .socketOption = {.addr = "127.0.0.1",
848 .port = 6666,
849 .moduleId = PROXY,
850 .protocol = LNN_PROTOCOL_IP}
851 };
852
853 for (module = PROXY; module < LISTENER_MODULE_DYNAMIC_START; module++) {
854 info.socketOption.port++;
855 info.socketOption.moduleId = static_cast<ListenerModule>(module);
856
857 SoftbusBaseListener *listener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
858 ASSERT_TRUE(listener != nullptr);
859 listener->onConnectEvent = ConnectEvent;
860 listener->onDataEvent = DataEvent;
861 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(static_cast<ListenerModule>(module), listener));
862
863 EXPECT_EQ(SOFTBUS_INVALID_PARAM,
864 AddTrigger(static_cast<ListenerModule>(module), fd, static_cast<TriggerType>(READ_TRIGGER - 1)));
865 EXPECT_EQ(SOFTBUS_INVALID_PARAM,
866 AddTrigger(static_cast<ListenerModule>(module), fd, static_cast<TriggerType>(RW_TRIGGER + 1)));
867 EXPECT_EQ(SOFTBUS_INVALID_PARAM,
868 DelTrigger(static_cast<ListenerModule>(module), fd, static_cast<TriggerType>(READ_TRIGGER - 1)));
869 EXPECT_EQ(SOFTBUS_INVALID_PARAM,
870 DelTrigger(static_cast<ListenerModule>(module), fd, static_cast<TriggerType>(RW_TRIGGER + 1)));
871
872 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(module)));
873 free(listener);
874 }
875 };
876
877 /*
878 * @tc.name: testBaseListener031
879 * @tc.desc: Test DestroyBaseListener valid input param.
880 * @tc.in: Test module, Test number, Test Levels.
881 * @tc.out: Zero
882 * @tc.type: FUNC
883 * @tc.require: The DestroyBaseListener operates normally.
884 */
885 HWTEST_F(SoftbusCommonTest, testBaseListener031, TestSize.Level1)
886 {
887 ListenerModule module = PROXY;
888 LocalListenerInfo info = {
889 .type = CONNECT_TCP,
890 .socketOption = {.addr = "127.0.0.1",
891 .port = 6666,
892 .moduleId = module,
893 .protocol = LNN_PROTOCOL_IP}
894 };
895 SoftbusBaseListener *listener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
896 ASSERT_TRUE(listener != nullptr);
897 listener->onConnectEvent = ConnectEvent;
898 listener->onDataEvent = DataEvent;
899 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(module, listener));
900 EXPECT_EQ(info.socketOption.port, StartBaseListener(&info));
901
902 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(module));
903
904 EXPECT_EQ(info.socketOption.port, StartBaseListener(&info));
905 free(listener);
906 };
907
908 /*
909 * @tc.name: testBaseListener032
910 * @tc.desc: Test DestroyBaseListener empty corresponding module listener.
911 * @tc.in: Test module, Test number, Test Levels.
912 * @tc.out: Zero
913 * @tc.type: FUNC
914 * @tc.require: The DestroyBaseListener and StartBaseListener operates normally.
915 */
916 HWTEST_F(SoftbusCommonTest, testBaseListener032, TestSize.Level1)
917 {
918 const int port = 6666;
919 LocalListenerInfo info = {
920 .type = CONNECT_TCP,
921 .socketOption = {.addr = "127.0.0.1",
922 .port = port,
923 .moduleId = PROXY,
924 .protocol = LNN_PROTOCOL_IP}
925 };
926
927 SoftbusBaseListener *listener1 = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
928 ASSERT_TRUE(listener1 != nullptr);
929 listener1->onConnectEvent = ConnectEvent;
930 listener1->onDataEvent = DataEvent;
931 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(PROXY, listener1));
932 EXPECT_EQ(SOFTBUS_ERR, StartBaseListener(&info));
933
934 SoftbusBaseListener *listener2 = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
935 ASSERT_TRUE(listener2 != nullptr);
936 listener2->onConnectEvent = ConnectEvent;
937 listener2->onDataEvent = DataEvent;
938 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(AUTH, listener2));
939
940 info.socketOption.moduleId = AUTH;
941 info.socketOption.port = AUTH + port;
942 EXPECT_EQ(AUTH + port, StartBaseListener(&info));
943
944 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(PROXY));
945 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(AUTH));
946
947 info.socketOption.moduleId = PROXY;
948 info.socketOption.port = PROXY + port;
949 EXPECT_EQ(port, StartBaseListener(&info));
950
951 info.socketOption.moduleId = AUTH;
952 info.socketOption.port = AUTH + port;
953 EXPECT_EQ(AUTH + port, StartBaseListener(&info));
954
955 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(AUTH));
956 EXPECT_EQ(AUTH + port, StartBaseListener(&info));
957 free(listener1);
958 free(listener2);
959 };
960
961 /*
962 * @tc.name: testBaseListener033
963 * @tc.desc: Test DestroyBaseListener without StopBaseListener.
964 * @tc.in: Test module, Test number, Test Levels.
965 * @tc.out: NonZero
966 * @tc.type: FUNC
967 * @tc.require: The StartBaseListener operates normally.
968 */
969 HWTEST_F(SoftbusCommonTest, testBaseListener033, TestSize.Level1)
970 {
971 ListenerModule module = PROXY;
972 const int port = 6666;
973
974 LocalListenerInfo info = {
975 .type = CONNECT_TCP,
976 .socketOption = {.addr = "127.0.0.1",
977 .port = port,
978 .moduleId = PROXY,
979 .protocol = LNN_PROTOCOL_IP}
980 };
981
982 SoftbusBaseListener *listener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
983 ASSERT_TRUE(listener != nullptr);
984 listener->onConnectEvent = ConnectEvent;
985 listener->onDataEvent = DataEvent;
986 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(module, listener));
987
988 EXPECT_EQ(SOFTBUS_ERR, StartBaseListener(&info));
989 free(listener);
990 };
991
992 /*
993 * @tc.name: testBaseListener034
994 * @tc.desc: Test AddTrigger with empty info.
995 * @tc.in: Test module, Test number, Test Levels.
996 * @tc.out: NonZero
997 * @tc.type: FUNC
998 * @tc.require: The AddTrigger operates normally.
999 */
1000 HWTEST_F(SoftbusCommonTest, testBaseListener034, TestSize.Level1)
1001 {
1002 ListenerModule module = PROXY;
1003 int triggerType = READ_TRIGGER;
1004 int fd = 1;
1005 const int port = 6666;
1006
1007 LocalListenerInfo info = {
1008 .type = CONNECT_TCP,
1009 .socketOption = {.addr = "127.0.0.1",
1010 .port = port,
1011 .moduleId = PROXY,
1012 .protocol = LNN_PROTOCOL_IP}
1013 };
1014
1015 SoftbusBaseListener *listener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
1016 ASSERT_TRUE(listener != nullptr);
1017 listener->onConnectEvent = ConnectEvent;
1018 listener->onDataEvent = DataEvent;
1019 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(static_cast<ListenerModule>(module), listener));
1020 EXPECT_EQ(SOFTBUS_ERR, StartBaseListener(&info));
1021
1022 EXPECT_EQ(SOFTBUS_OK, AddTrigger(static_cast<ListenerModule>(module), fd, static_cast<TriggerType>(triggerType)));
1023 free(listener);
1024 };
1025
1026 /*
1027 * @tc.name: testBaseListener035
1028 * @tc.desc: Test DelTrigger with empty info.
1029 * @tc.in: Test module, Test number, Test Levels.
1030 * @tc.out: NonZero
1031 * @tc.type: FUNC
1032 * @tc.require: The DelTrigger operates normally.
1033 */
1034 HWTEST_F(SoftbusCommonTest, testBaseListener035, TestSize.Level1)
1035 {
1036 int module = PROXY;
1037 int triggerType = READ_TRIGGER;
1038 int fd = 1;
1039 const int port = 6666;
1040
1041 LocalListenerInfo info = {
1042 .type = CONNECT_TCP,
1043 .socketOption = {.addr = "127.0.0.1",
1044 .port = port,
1045 .moduleId = PROXY,
1046 .protocol = LNN_PROTOCOL_IP}
1047 };
1048
1049 SoftbusBaseListener *listener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
1050 ASSERT_TRUE(listener != nullptr);
1051 listener->onConnectEvent = ConnectEvent;
1052 listener->onDataEvent = DataEvent;
1053 EXPECT_EQ(SOFTBUS_OK, SetSoftbusBaseListener(static_cast<ListenerModule>(module), listener));
1054 EXPECT_EQ(SOFTBUS_ERR, StartBaseListener(&info));
1055
1056 EXPECT_EQ(SOFTBUS_OK, DelTrigger(static_cast<ListenerModule>(module), fd, static_cast<TriggerType>(triggerType)));
1057 free(listener);
1058 };
1059
1060 /*
1061 * @tc.name: testTcpSocket001
1062 * @tc.desc: test OpenTcpServerSocket
1063 * @tc.type: FUNC
1064 * @tc.require:
1065 */
1066 HWTEST_F(SoftbusCommonTest, testTcpSocket001, TestSize.Level1)
1067 {
1068 const SocketInterface *tcp = GetTcpProtocol();
1069 ASSERT_NE(tcp, nullptr);
1070
1071 LocalListenerInfo info = {
1072 .type = CONNECT_TCP,
1073 .socketOption = {
1074 .addr = "127.0.0.1",
1075 .port = g_port,
1076 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
1077 .protocol = LNN_PROTOCOL_IP
1078 }
1079 };
1080
1081 int fd = tcp->OpenServerSocket(&info);
1082 int ret = (fd <= 0) ? SOFTBUS_ERR : SOFTBUS_OK;
1083 ASSERT_TRUE(ret == SOFTBUS_OK);
1084 int port = tcp->GetSockPort(fd);
1085 EXPECT_EQ(port, g_port);
1086 ConnCloseSocket(fd);
1087
1088 fd = tcp->OpenServerSocket(nullptr);
1089 ret = (fd <= 0) ? SOFTBUS_ERR : SOFTBUS_OK;
1090 EXPECT_EQ(ret, SOFTBUS_ERR);
1091 ConnCloseSocket(fd);
1092
1093 info.socketOption.port = -1;
1094 fd = tcp->OpenServerSocket(&info);
1095 ret = (fd <= 0) ? SOFTBUS_ERR : SOFTBUS_OK;
1096 EXPECT_EQ(ret, SOFTBUS_ERR);
1097 ConnCloseSocket(fd);
1098 };
1099
1100 /*
1101 * @tc.name: testTcpSocket002
1102 * @tc.desc: test OpenTcpClientSocket
1103 * @tc.type: FUNC
1104 * @tc.require:
1105 */
1106 HWTEST_F(SoftbusCommonTest, testTcpSocket002, TestSize.Level1)
1107 {
1108 const SocketInterface *tcp = GetTcpProtocol();
1109 ASSERT_NE(tcp, nullptr);
1110
1111 ConnectOption option = {
1112 .type = CONNECT_TCP,
1113 .socketOption = {
1114 .addr = "127.0.0.1",
1115 .port = g_port,
1116 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
1117 .protocol = LNN_PROTOCOL_IP
1118 }
1119 };
1120
1121 int fd = tcp->OpenClientSocket(nullptr, "127.0.0.1", false);
1122 int ret = (fd < 0) ? SOFTBUS_ERR : SOFTBUS_OK;
1123 EXPECT_EQ(ret, SOFTBUS_ERR);
1124 ConnCloseSocket(fd);
1125 fd = tcp->OpenClientSocket(nullptr, nullptr, false);
1126 ret = (fd < 0) ? SOFTBUS_ERR : SOFTBUS_OK;
1127 EXPECT_EQ(ret, SOFTBUS_ERR);
1128 ConnCloseSocket(fd);
1129
1130 option.socketOption.port = -1;
1131 fd = tcp->OpenClientSocket(&option, "127.0.0.1", false);
1132 ret = (fd < 0) ? SOFTBUS_ERR : SOFTBUS_OK;
1133 EXPECT_EQ(ret, SOFTBUS_ERR);
1134 ConnCloseSocket(fd);
1135 };
1136
1137 /*
1138 * @tc.name: testBaseListener003
1139 * @tc.desc: test GetTcpSockPort invalid fd
1140 * @tc.type: FUNC
1141 * @tc.require:
1142 */
1143 HWTEST_F(SoftbusCommonTest, testTcpSocket003, TestSize.Level1)
1144 {
1145 const SocketInterface *tcp = GetTcpProtocol();
1146 ASSERT_NE(tcp, nullptr);
1147 int invalidFd = 1;
1148 int port = tcp->GetSockPort(invalidFd);
1149 int ret = (port <= 0) ? SOFTBUS_ERR : SOFTBUS_OK;
1150 EXPECT_EQ(ret, SOFTBUS_ERR);
1151 };
1152
1153 /*
1154 * @tc.name: testTcpSocket004
1155 * @tc.desc: test ConnSendSocketData invalid fd
1156 * @tc.type: FUNC
1157 * @tc.require:
1158 */
1159 HWTEST_F(SoftbusCommonTest, testTcpSocket004, TestSize.Level1)
1160 {
1161 const SocketInterface *tcp = GetTcpProtocol();
1162 ASSERT_NE(tcp, nullptr);
1163
1164 int clientFd = tcp->OpenClientSocket(nullptr, "127.5.0.1", false);
1165 int ret = (clientFd < 0) ? SOFTBUS_ERR : SOFTBUS_OK;
1166 EXPECT_EQ(ret, SOFTBUS_ERR);
1167 ssize_t bytes = ConnSendSocketData(clientFd, "Hello world", 11, 0);
1168 EXPECT_EQ(bytes, -1);
1169 ConnShutdownSocket(clientFd);
1170 };
1171
1172 /*
1173 * @tc.name: testThreadPool001
1174 * @tc.desc: test ThreadPoolInit invalid input param
1175 * @tc.type: FUNC
1176 * @tc.require:
1177 */
1178 HWTEST_F(SoftbusCommonTest, testThreadPool001, TestSize.Level1)
1179 {
1180 int threadNum = 2;
1181 int queueMaxNum = 4;
1182 int invalidNum = 0;
1183
1184 ThreadPool *pool = ThreadPoolInit(invalidNum, queueMaxNum);
1185 EXPECT_EQ(nullptr, pool);
1186 pool = ThreadPoolInit(threadNum, invalidNum);
1187 EXPECT_EQ(nullptr, pool);
1188 pool = ThreadPoolInit(threadNum, queueMaxNum);
1189 EXPECT_EQ(true, pool != nullptr);
1190
1191 EXPECT_EQ(SOFTBUS_OK, ThreadPoolDestroy(pool));
1192 }
1193
1194 /*
1195 * @tc.name: testThreadPool002
1196 * @tc.desc: test ThreadPoolAddJob and remove with invalid param
1197 * @tc.type: FUNC
1198 * @tc.require:
1199 */
1200 HWTEST_F(SoftbusCommonTest, testThreadPool002, TestSize.Level1)
1201 {
1202 int threadNum = 2;
1203 int queueMaxNum = 4;
1204
1205 ThreadPool *pool = ThreadPoolInit(threadNum, queueMaxNum);
1206 EXPECT_EQ(true, pool != nullptr);
1207
1208 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ThreadPoolAddJob(nullptr, ThreadPoolTask, nullptr, ONCE, (uintptr_t)0));
1209 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ThreadPoolAddJob(nullptr, ThreadPoolTask, nullptr, PERSISTENT, (uintptr_t)0));
1210 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ThreadPoolAddJob(pool, nullptr, nullptr, ONCE, (uintptr_t)0));
1211 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ThreadPoolAddJob(pool, nullptr, nullptr, PERSISTENT, (uintptr_t)0));
1212
1213 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ThreadPoolRemoveJob(nullptr, (uintptr_t)0));
1214 EXPECT_EQ(SOFTBUS_OK, ThreadPoolDestroy(pool));
1215 }
1216
1217 /*
1218 * @tc.name: testThreadPool003
1219 * @tc.desc: test null ThreadPoolDestroy
1220 * @tc.type: FUNC
1221 * @tc.require:
1222 */
1223 HWTEST_F(SoftbusCommonTest, testThreadPool003, TestSize.Level1)
1224 {
1225 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ThreadPoolDestroy(nullptr));
1226 }
1227
1228 /*
1229 * @tc.name: testThreadPool004
1230 * @tc.desc: test ThreadPoolAddJob out of max num
1231 * @tc.type: FUNC
1232 * @tc.require:
1233 */
1234 HWTEST_F(SoftbusCommonTest, testThreadPool004, TestSize.Level1)
1235 {
1236 int threadNum = 2;
1237 int queueMaxNum = 4;
1238
1239 ThreadPool *pool = ThreadPoolInit(threadNum, queueMaxNum);
1240 int ret = (pool != nullptr) ? SOFTBUS_OK : SOFTBUS_ERR;
1241 EXPECT_EQ(ret, SOFTBUS_OK);
1242
1243 for (int i = 0; i < queueMaxNum; i++) {
1244 ret = ThreadPoolAddJob(pool, ThreadPoolTask, nullptr, PERSISTENT, (uintptr_t)i);
1245 EXPECT_EQ(ret, SOFTBUS_OK);
1246 }
1247 ret = ThreadPoolAddJob(pool, ThreadPoolTask, nullptr, PERSISTENT, (uintptr_t)queueMaxNum);
1248 EXPECT_EQ(ret, SOFTBUS_ERR);
1249 sleep(3);
1250 ret = (g_count != queueMaxNum) ? SOFTBUS_OK : SOFTBUS_ERR;
1251 EXPECT_EQ(ret, SOFTBUS_OK);
1252 for (int i = 0; i < queueMaxNum; i++) {
1253 ret = ThreadPoolRemoveJob(pool, (uintptr_t)i);
1254 EXPECT_EQ(ret, SOFTBUS_OK);
1255 }
1256 ret = ThreadPoolRemoveJob(pool, (uintptr_t)queueMaxNum);
1257 EXPECT_EQ(ret, SOFTBUS_OK);
1258 if (pool != nullptr) {
1259 ret = ThreadPoolDestroy(pool);
1260 EXPECT_EQ(ret, SOFTBUS_OK);
1261 }
1262 };
1263
1264 /*
1265 * @tc.name: testThreadPool005
1266 * @tc.desc: test ThreadPoolAddJob and remove
1267 * @tc.type: FUNC
1268 * @tc.require:
1269 */
1270 HWTEST_F(SoftbusCommonTest, testThreadPool005, TestSize.Level1)
1271 {
1272 int threadNum = 2;
1273 int queueMaxNum = 4;
1274
1275 ThreadPool *pool = ThreadPoolInit(threadNum, queueMaxNum);
1276 int ret = (pool != nullptr) ? SOFTBUS_OK : SOFTBUS_ERR;
1277 EXPECT_EQ(ret, SOFTBUS_OK);
1278
1279 for (int i = 0; i < queueMaxNum; i++) {
1280 ret = ThreadPoolAddJob(pool, ThreadPoolTask, nullptr, ONCE, (uintptr_t)i);
1281 EXPECT_EQ(ret, SOFTBUS_OK);
1282 }
1283 sleep(3);
1284 EXPECT_EQ(queueMaxNum, g_count);
1285 for (int i = 0; i < queueMaxNum; i++) {
1286 ret = ThreadPoolRemoveJob(pool, (uintptr_t)i);
1287 EXPECT_EQ(ret, SOFTBUS_OK);
1288 }
1289 if (pool != nullptr) {
1290 ret = ThreadPoolDestroy(pool);
1291 EXPECT_EQ(ret, SOFTBUS_OK);
1292 }
1293 };
1294
1295 /*
1296 * @tc.name: testThreadPool006
1297 * @tc.desc: test ThreadPoolAddJob after pool == nullptr
1298 * @tec.in: test module,test number,test levels.
1299 * @tc.out: Nonzero
1300 * @tc.type: FUNC
1301 * @tc.require: ThreadPoolAddJob and ThreadPoolDestroy and ThreadPoolInit operates normally.
1302 */
1303 HWTEST_F(SoftbusCommonTest, testThreadPool006, TestSize.Level1)
1304 {
1305 int threadNum = 1;
1306 int queueMaxNum = 2;
1307 g_count = 0;
1308
1309 ThreadPool *pool = ThreadPoolInit(threadNum, queueMaxNum);
1310 int ret = (pool != nullptr) ? SOFTBUS_OK : SOFTBUS_ERR;
1311 EXPECT_EQ(ret, SOFTBUS_OK);
1312
1313 if (pool != nullptr) {
1314 ret = ThreadPoolDestroy(pool);
1315 pool = nullptr;
1316 EXPECT_EQ(ret, SOFTBUS_OK);
1317 }
1318
1319 int handId = 0;
1320 ret = ThreadPoolAddJob(pool, ThreadPoolTask, nullptr, ONCE, (uintptr_t)handId);
1321 EXPECT_TRUE(ret != SOFTBUS_OK);
1322 };
1323
1324 /*
1325 * @tc.name: testThreadPool007
1326 * @tc.desc: Test call ThreadPoolAddJob twice to create a thread twice.
1327 * @tc.in: test module, test number, test levels.
1328 * @tc.out: Nonzero
1329 * @tc.type: FUNC
1330 * @tc.require: ThreadPoolInit and ThreadPoolAddJob and ThreadPoolDestroy operates normally.
1331 */
1332 HWTEST_F(SoftbusCommonTest, testThreadPool007, TestSize.Level1)
1333 {
1334 int threadNum = 2;
1335 int queueMaxNum = 4;
1336 g_count = 0;
1337
1338 ThreadPool *pool = ThreadPoolInit(threadNum, queueMaxNum);
1339 int ret = (pool != nullptr) ? SOFTBUS_OK : SOFTBUS_ERR;
1340 EXPECT_EQ(ret, SOFTBUS_OK);
1341
1342 int handId = 0;
1343 ret = ThreadPoolAddJob(pool, ThreadPoolTask, nullptr, PERSISTENT, (uintptr_t)handId);
1344 EXPECT_EQ(ret, SOFTBUS_OK);
1345
1346 ret = ThreadPoolAddJob(pool, ThreadPoolTask, nullptr, PERSISTENT, (uintptr_t)handId);
1347 EXPECT_EQ(ret, SOFTBUS_ALREADY_EXISTED);
1348
1349 if (pool != nullptr) {
1350 ret = ThreadPoolDestroy(pool);
1351 EXPECT_EQ(ret, SOFTBUS_OK);
1352 }
1353 };
1354
1355 /*
1356 * @tc.name: testThreadPool008
1357 * @tc.desc: Test ThreadPoolAddJob when queueCurNum add some jobs.
1358 * @tc.in: test module, test number, test levels.
1359 * @tc.out: Zero
1360 * @tc.type: FUNC
1361 * @tc.require: The testGThreadPool operates normally.
1362 */
1363 HWTEST_F(SoftbusCommonTest, testThreadPool008, TestSize.Level1)
1364 {
1365 int threadNum = 2;
1366 int queueMaxNum = 4;
1367 g_count = 0;
1368
1369 ThreadPool *pool = ThreadPoolInit(threadNum, queueMaxNum);
1370 int ret = (pool != nullptr) ? SOFTBUS_OK : SOFTBUS_ERR;
1371 EXPECT_EQ(ret, SOFTBUS_OK);
1372
1373 for (int i = 0; i < queueMaxNum; i++) {
1374 ret = ThreadPoolAddJob(pool, ThreadPoolTask, nullptr, PERSISTENT, (uintptr_t)i);
1375 EXPECT_EQ(ret, SOFTBUS_OK);
1376 }
1377
1378 usleep(500);
1379 if (pool != nullptr) {
1380 ret = ThreadPoolDestroy(pool);
1381 EXPECT_EQ(ret, SOFTBUS_OK);
1382 }
1383 };
1384
1385 /*
1386 * @tc.name: testThreadPool009
1387 * @tc.desc: Test ThreadPoolAddJob when ThreadPoolInit failed.
1388 * @tc.in: test module, test number, test levels.
1389 * @tc.out: Nonzero
1390 * @tc.type: FUNC
1391 * @tc.require: The testGThreadPool operates normally.
1392 */
1393 HWTEST_F(SoftbusCommonTest, testThreadPool009, TestSize.Level1)
1394 {
1395 int threadNum = -1;
1396 int queueMaxNum = -1;
1397 g_count = 0;
1398
1399 ThreadPool *pool = ThreadPoolInit(threadNum, queueMaxNum);
1400 int ret = (pool != nullptr) ? SOFTBUS_OK : SOFTBUS_ERR;
1401 EXPECT_EQ(ret, SOFTBUS_ERR);
1402
1403 int handId = 0;
1404 ret = ThreadPoolAddJob(pool, ThreadPoolTask, nullptr, PERSISTENT, (uintptr_t)handId);
1405 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1406
1407 if (pool != nullptr) {
1408 ret = ThreadPoolDestroy(pool);
1409 EXPECT_EQ(ret, SOFTBUS_OK);
1410 }
1411 };
1412
1413 /*
1414 * @tc.name: testThreadPool010
1415 * @tc.desc: Test ThreadPoolAddJob when add the same handle but different jobMode.
1416 * @tc.in: test module, test number, test levels.
1417 * @tc.out: Nonzero
1418 * @tc.type: FUNC
1419 * @tc.require: The testGThreadPool operates normally.
1420 */
1421 HWTEST_F(SoftbusCommonTest, testThreadPool010, TestSize.Level1)
1422 {
1423 int threadNum = 2;
1424 int queueMaxNum = 4;
1425 g_count = 0;
1426
1427 ThreadPool *pool = ThreadPoolInit(threadNum, queueMaxNum);
1428 int ret = (pool != nullptr) ? SOFTBUS_OK : SOFTBUS_ERR;
1429 EXPECT_EQ(ret, SOFTBUS_OK);
1430
1431 if (nullptr != pool) {
1432 int handId = 0;
1433 ret = ThreadPoolAddJob(pool, ThreadPoolTask, nullptr, ONCE, (uintptr_t)handId);
1434 EXPECT_EQ(ret, SOFTBUS_OK);
1435
1436 ret = ThreadPoolDestroy(pool);
1437 EXPECT_EQ(ret, SOFTBUS_OK);
1438 }
1439 };
1440
1441 /*
1442 * @tc.name: testThreadPool011
1443 * @tc.desc: Test ThreadPoolAddJob add the same handle when jobMode is ONCE.
1444 * @tc.in: test module, test number, test levels.
1445 * @tc.out: Nonzero
1446 * @tc.type: FUNC
1447 * @tc.require: The ThreadPoolAddJob operates normally.
1448 */
1449 HWTEST_F(SoftbusCommonTest, testThreadPool011, TestSize.Level1)
1450 {
1451 int threadNum = 2;
1452 int queueMaxNum = 4;
1453 g_count = 0;
1454
1455 ThreadPool *pool = ThreadPoolInit(threadNum, queueMaxNum);
1456 int ret = (pool != nullptr) ? SOFTBUS_OK : SOFTBUS_ERR;
1457 EXPECT_EQ(ret, SOFTBUS_OK);
1458
1459 if (nullptr != pool) {
1460 for (int i = 0; i < queueMaxNum; i++) {
1461 ret = ThreadPoolAddJob(pool, ThreadPoolTask, nullptr, ONCE, (uintptr_t)i);
1462 EXPECT_EQ(ret, SOFTBUS_OK);
1463 }
1464
1465 ret = ThreadPoolDestroy(pool);
1466 EXPECT_EQ(ret, SOFTBUS_OK);
1467 }
1468 };
1469
1470 /*
1471 * @tc.name: testThreadPool012
1472 * @tc.desc: Test ThreadPoolRemoveJob when handId out of max.
1473 * @tc.in: test module, test number, test levels.
1474 * @tc.out: Nonzero
1475 * @tc.type: FUNC
1476 * @tc.require: The ThreadPoolRemoveJob operates normally.
1477 */
1478 HWTEST_F(SoftbusCommonTest, testThreadPool012, TestSize.Level1)
1479 {
1480 int threadNum = 2;
1481 int queueMaxNum = 4;
1482 g_count = 0;
1483
1484 ThreadPool *pool = ThreadPoolInit(threadNum, queueMaxNum);
1485 int ret = (pool != nullptr) ? SOFTBUS_OK : SOFTBUS_ERR;
1486 EXPECT_EQ(ret, SOFTBUS_OK);
1487
1488 if (nullptr != pool) {
1489 for (int i = 0; i < queueMaxNum; i++) {
1490 ret = ThreadPoolAddJob(pool, ThreadPoolTask, nullptr, ONCE, (uintptr_t)i);
1491 EXPECT_EQ(ret, SOFTBUS_OK);
1492 }
1493
1494 ret = ThreadPoolRemoveJob(pool, (uintptr_t)queueMaxNum);
1495 EXPECT_EQ(ret, SOFTBUS_OK);
1496
1497 ret = ThreadPoolDestroy(pool);
1498 EXPECT_EQ(ret, SOFTBUS_OK);
1499 }
1500 };
1501
1502 /*
1503 * @tc.name: testThreadPool013
1504 * @tc.desc: Test ThreadPoolRemoveJob when no add job.
1505 * @tc.in: test module, test number, test levels.
1506 * @tc.out: Zero
1507 * @tc.type: FUNC
1508 * @tc.require: The ThreadPoolRemoveJob operates normally.
1509 */
1510 HWTEST_F(SoftbusCommonTest, testThreadPool013, TestSize.Level1)
1511 {
1512 int threadNum = 2;
1513 int queueMaxNum = 4;
1514
1515 ThreadPool *pool = ThreadPoolInit(threadNum, queueMaxNum);
1516 int ret = (pool != nullptr) ? SOFTBUS_OK : SOFTBUS_ERR;
1517 EXPECT_EQ(ret, SOFTBUS_OK);
1518
1519 int handId = 0;
1520 ret = ThreadPoolRemoveJob(pool, (uintptr_t)handId);
1521 EXPECT_EQ(ret, SOFTBUS_OK);
1522
1523 if (pool != nullptr) {
1524 ret = ThreadPoolDestroy(pool);
1525 EXPECT_EQ(ret, SOFTBUS_OK);
1526 }
1527 };
1528
1529 /*
1530 * @tc.name: testThreadPool014
1531 * @tc.desc: Test ThreadPoolRemoveJob remove the same handle when the added job mode is ONCE.
1532 * @tc.in: test module, test number, test levels.
1533 * @tc.out: Zero
1534 * @tc.type: FUNC
1535 * @tc.require: The ThreadPoolRemoveJob operates normally.
1536 */
1537 HWTEST_F(SoftbusCommonTest, testThreadPool014, TestSize.Level1)
1538 {
1539 int threadNum = 2;
1540 int queueMaxNum = 4;
1541 g_count = 0;
1542
1543 ThreadPool *pool = ThreadPoolInit(threadNum, queueMaxNum);
1544 int ret = (pool != nullptr) ? SOFTBUS_OK : SOFTBUS_ERR;
1545 EXPECT_EQ(ret, SOFTBUS_OK);
1546
1547 for (int i = 0; i < queueMaxNum; i++) {
1548 ret = ThreadPoolAddJob(pool, ThreadPoolTask, nullptr, ONCE, (uintptr_t)i);
1549 EXPECT_EQ(ret, SOFTBUS_OK);
1550 }
1551 usleep(1000);
1552
1553 int handId = 0;
1554 ret = ThreadPoolRemoveJob(pool, (uintptr_t)handId);
1555 EXPECT_EQ(ret, SOFTBUS_OK);
1556
1557 ret = ThreadPoolRemoveJob(pool, (uintptr_t)handId);
1558 EXPECT_EQ(ret, SOFTBUS_OK);
1559
1560 if (pool != nullptr) {
1561 ret = ThreadPoolDestroy(pool);
1562 EXPECT_EQ(ret, SOFTBUS_OK);
1563 }
1564 };
1565
1566 /*
1567 * @tc.name: testThreadPool015
1568 * @tc.desc: Test ThreadPoolRemoveJob when ThreadPoolInit failed.
1569 * @tc.in: test module, test number, test levels.
1570 * @tc.out: Nonzero
1571 * @tc.type: FUNC
1572 * @tc.require: The ThreadPoolRemoveJob operates normally.
1573 */
1574 HWTEST_F(SoftbusCommonTest, testThreadPool015, TestSize.Level1)
1575 {
1576 int threadNum = -1;
1577 int queueMaxNum = -1;
1578 g_count = 0;
1579
1580 ThreadPool *pool = ThreadPoolInit(threadNum, queueMaxNum);
1581 int ret = (pool != nullptr) ? SOFTBUS_OK : SOFTBUS_ERR;
1582 EXPECT_EQ(ret, SOFTBUS_ERR);
1583
1584 int handId = 0;
1585 ret = ThreadPoolAddJob(pool, ThreadPoolTask, nullptr, ONCE, (uintptr_t)handId);
1586 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1587
1588 ret = ThreadPoolRemoveJob(pool, (uintptr_t)handId);
1589 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1590
1591 if (pool != nullptr) {
1592 ret = ThreadPoolDestroy(pool);
1593 EXPECT_EQ(ret, SOFTBUS_OK);
1594 }
1595 };
1596
1597 /*
1598 * @tc.name: testThreadPool016
1599 * @tc.desc: Test ThreadPoolRemoveJob remove the same hand when the added job mode is PERSISTENT.
1600 * @tc.in: test module, test number, test levels.
1601 * @tc.out: Zero
1602 * @tc.type: FUNC
1603 * @tc.require: The ThreadPoolRemoveJob operates normally.
1604 */
1605 HWTEST_F(SoftbusCommonTest, testThreadPool016, TestSize.Level1)
1606 {
1607 int threadNum = 2;
1608 int queueMaxNum = 4;
1609 g_count = 0;
1610
1611 ThreadPool *pool = ThreadPoolInit(threadNum, queueMaxNum);
1612 int ret = (pool != nullptr) ? SOFTBUS_OK : SOFTBUS_ERR;
1613 EXPECT_EQ(ret, SOFTBUS_OK);
1614
1615 if (nullptr != pool) {
1616 for (int i = 0; i < queueMaxNum; i++) {
1617 ret = ThreadPoolAddJob(pool, ThreadPoolTask, nullptr, PERSISTENT, (uintptr_t)i);
1618 EXPECT_EQ(ret, SOFTBUS_OK);
1619 }
1620
1621 int handId = 0;
1622 ret = ThreadPoolRemoveJob(pool, (uintptr_t)handId);
1623 EXPECT_EQ(ret, SOFTBUS_OK);
1624
1625 ret = ThreadPoolRemoveJob(pool, (uintptr_t)handId);
1626 EXPECT_EQ(ret, SOFTBUS_OK);
1627
1628 ret = ThreadPoolDestroy(pool);
1629 EXPECT_EQ(ret, SOFTBUS_OK);
1630 }
1631 };
1632
1633 /*
1634 * @tc.name: testThreadPool017
1635 * @tc.desc: Test ThreadPoolDestroy under normal process.
1636 * @tc.in: test module, test number, test levels.
1637 * @tc.out: Zero
1638 * @tc.type: FUNC
1639 * @tc.require: The testGThreadPool operates normally.
1640 */
1641 HWTEST_F(SoftbusCommonTest, testThreadPool017, TestSize.Level1)
1642 {
1643 int threadNum = 2;
1644 int queueMaxNum = 4;
1645
1646 ThreadPool *pool = ThreadPoolInit(threadNum, queueMaxNum);
1647 int ret = (pool != nullptr) ? SOFTBUS_OK : SOFTBUS_ERR;
1648 EXPECT_EQ(ret, SOFTBUS_OK);
1649
1650 if (pool != nullptr) {
1651 ret = ThreadPoolDestroy(pool);
1652 EXPECT_EQ(ret, SOFTBUS_OK);
1653 }
1654 };
1655
1656 /*
1657 * @tc.name: testThreadPool018
1658 * @tc.desc: Test ThreadPoolDestroy when ThreadPoolInit failed
1659 * @tc.in: test module,test number,test levels.
1660 * @tc.out: Nonzero
1661 * @tc.type: FUNC
1662 * @tc.require: The ThreadPoolDestroy operates normally.
1663 */
1664 HWTEST_F(SoftbusCommonTest, testThreadPool018, TestSize.Level1)
1665 {
1666 int threadNum = -1;
1667 int queueMaxNum = -1;
1668
1669 ThreadPool *pool = ThreadPoolInit(threadNum, queueMaxNum);
1670 int ret = (pool != nullptr) ? SOFTBUS_OK : SOFTBUS_ERR;
1671 EXPECT_EQ(ret, SOFTBUS_ERR);
1672
1673 ret = ThreadPoolDestroy(pool);
1674 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1675 };
1676
1677 /*
1678 * @tc.name: testThreadPool019
1679 * @tc.desc: Test ThreadPoolDestroy when not ThreadPoolAddJob.
1680 * @tc.in: test module, test number,test levels.
1681 * @tc.out: Zero
1682 * @tc.type: FUNC
1683 * @tc.require: The ThreadPoolDestroy operates normally.
1684 */
1685 HWTEST_F(SoftbusCommonTest, testThreadPool019, TestSize.Level1)
1686 {
1687 int threadNum = 1;
1688 int queueMaxNum = 4;
1689
1690 ThreadPool *pool = ThreadPoolInit(threadNum, queueMaxNum);
1691 int ret = (pool != nullptr) ? SOFTBUS_OK : SOFTBUS_ERR;
1692 EXPECT_EQ(ret, SOFTBUS_OK);
1693
1694 if (nullptr != pool) {
1695 ret = ThreadPoolDestroy(pool);
1696 EXPECT_EQ(ret, SOFTBUS_OK);
1697 }
1698 };
1699
1700 /*
1701 * @tc.name: testThreadPool020
1702 * @tc.desc: Test ThreadPoolDestroy when not ThreadPoolRemoveJob.
1703 * @tc.in: test module, test number, test levels.
1704 * @tc.out: Zero
1705 * @tc.type: FUNC
1706 * @tc.require: The ThreadPoolDestroy operates normally.
1707 */
1708 HWTEST_F(SoftbusCommonTest, testThreadPool020, TestSize.Level1)
1709 {
1710 int threadNum = 2;
1711 int queueMaxNum = 4;
1712 g_count = 0;
1713
1714 ThreadPool *pool = ThreadPoolInit(threadNum, queueMaxNum);
1715 int ret = (pool != nullptr) ? SOFTBUS_OK : SOFTBUS_ERR;
1716 EXPECT_EQ(ret, SOFTBUS_OK);
1717
1718 if (nullptr != pool) {
1719 for (int i = 0; i < queueMaxNum; i++) {
1720 ret = ThreadPoolAddJob(pool, ThreadPoolTask, nullptr, PERSISTENT, (uintptr_t)i);
1721 EXPECT_EQ(ret, SOFTBUS_OK);
1722 }
1723 ret = ThreadPoolDestroy(pool);
1724 EXPECT_EQ(ret, SOFTBUS_OK);
1725 }
1726 };
1727
1728 /*
1729 * @tc.name: testSocket001
1730 * @tc.desc: test ConnGetLocalSocketPort port
1731 * @tc.type: FUNC
1732 * @tc.require: I5PC1B
1733 */
1734 HWTEST_F(SoftbusCommonTest, testSocket001, TestSize.Level1)
1735 {
1736 int ret;
1737 ret = ConnGetLocalSocketPort(INVALID_FD);
1738 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
1739
1740 ret = ConnGetLocalSocketPort(TEST_FD);
1741 EXPECT_TRUE(ret < 0);
1742 };
1743
1744 /*
1745 * @tc.name: testSocket002
1746 * @tc.desc: test ConnGetPeerSocketAddr param is invalid
1747 * @tc.type: FUNC
1748 * @tc.require: I5PC1B
1749 */
1750 HWTEST_F(SoftbusCommonTest, testSocket002, TestSize.Level1)
1751 {
1752 int ret;
1753 ret = ConnGetPeerSocketAddr(INVALID_FD, &g_socketAddr);
1754 EXPECT_EQ(SOFTBUS_ERR, ret);
1755
1756 ret = ConnGetPeerSocketAddr(TEST_FD, NULL);
1757 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1758
1759 ret = ConnGetPeerSocketAddr(TEST_FD, &g_socketAddr);
1760 EXPECT_EQ(SOFTBUS_ERR, ret);
1761 };
1762
1763 /*
1764 * @tc.name: testConnSetTcpUserTimeOut001
1765 * @tc.desc: Test ConnSetTcpUserTimeOut param is invalid
1766 * @tc.in: test module, test number,test levels.
1767 * @tc.out: Zero
1768 * @tc.type: FUNC
1769 * @tc.require: The ThreadPoolDestroy operates normally.
1770 */
1771 HWTEST_F(SoftbusCommonTest, testConnSetTcpUserTimeOut001, TestSize.Level1)
1772 {
1773 int32_t fd = -1;
1774 uint32_t millSec= 1;
1775 int ret = ConnSetTcpUserTimeOut(fd, millSec);
1776 EXPECT_EQ(SOFTBUS_ERR, ret);
1777 }
1778
1779 /*
1780 * @tc.name: testConnSetTcpUserTimeOut002
1781 * @tc.desc: Test ConnSetTcpUserTimeOut param is invalid
1782 * @tc.in: test module, test number,test levels.
1783 * @tc.out: Zero
1784 * @tc.type: FUNC
1785 * @tc.require: The ThreadPoolDestroy operates normally.
1786 */
1787 HWTEST_F(SoftbusCommonTest, testConnSetTcpUserTimeOut002, TestSize.Level1)
1788 {
1789 int32_t fd = 1;
1790 uint32_t millSec= 321;
1791 int ret = ConnSetTcpUserTimeOut(fd, millSec);
1792 EXPECT_EQ(SOFTBUS_ERR, ret);
1793 }
1794
1795 /*
1796 * @tc.name: testSocket003
1797 * @tc.desc: test ConnGetPeerSocketAddr param is invalid
1798 * @tc.type: FUNC
1799 * @tc.require:
1800 */
1801 HWTEST_F(SoftbusCommonTest, testSocket003, TestSize.Level1)
1802 {
1803 int ret;
1804 SocketAddr socketAddr;
1805 ret = ConnGetPeerSocketAddr(INVALID_FD, &socketAddr);
1806 EXPECT_EQ(SOFTBUS_ERR, ret);
1807 }
1808
1809 /*
1810 * @tc.name: testSocket004
1811 * @tc.desc: test ConnGetLocalSocketPort port
1812 * @tc.type: FUNC
1813 * @tc.require:
1814 */
1815 HWTEST_F(SoftbusCommonTest, testSocket004, TestSize.Level1)
1816 {
1817 int ret;
1818 ret = ConnGetLocalSocketPort(INVALID_FD);
1819 EXPECT_EQ(SOFTBUS_ERR, ret);
1820 }
1821 }