1 /*
2 * Copyright (c) 2022-2024 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 "softbus_adapter_test.h"
17 #include "socket.h"
18 #include "softbus_adapter.h"
19 #include "token_setproc.h"
20
21 using namespace testing::ext;
22
23 static int g_mockBindReturnIntValue = 0;
24 static int g_mockListenReturnIntValue = 0;
25 static int g_mockSendBytesReturnIntValue = 0;
26 static int g_mockSendStreamReturnIntValue = 0;
27 static int g_mockSocketReturnIntValue = 0;
28
29 namespace OHOS {
30 namespace DistributedHardware {
31 namespace {
32 const std::string PEER_SESSION_NAME = "ohos.dhardware.dscreen.session8647073e02e7a78f09473aa125";
33 const std::string REMOTE_DEV_ID = "f6d4c0864707aefte7a78f09473aa122ff57fc81c00981fcf5be989e7d112125";
34 const std::string DSCREEN_PKG_NAME_TEST = "ohos.dhardware.dscreen";
35 }
SetUpTestCase(void)36 void SoftbusAdapterTest::SetUpTestCase(void) {}
37
TearDownTestCase(void)38 void SoftbusAdapterTest::TearDownTestCase(void) {}
39
SetUp(void)40 void SoftbusAdapterTest::SetUp(void)
41 {
42 g_mockBindReturnIntValue = 0;
43 g_mockListenReturnIntValue = 0;
44 g_mockSendBytesReturnIntValue = 0;
45 g_mockSendStreamReturnIntValue = 0;
46 g_mockSocketReturnIntValue = 0;
47 softbusAdapter_ = std::make_shared<SoftbusAdapter>();
48 }
49
TearDown(void)50 void SoftbusAdapterTest::TearDown(void)
51 {
52 softbusAdapter_ = nullptr;
53 }
54
ScreenOnSoftbusSessionOpened(int32_t sessionId,PeerSocketInfo info)55 static void ScreenOnSoftbusSessionOpened(int32_t sessionId, PeerSocketInfo info) {}
56
ScreenOnSoftbusSessionClosed(int32_t sessionId,ShutdownReason reason)57 static void ScreenOnSoftbusSessionClosed(int32_t sessionId, ShutdownReason reason) {}
58
ScreenOnBytesReceived(int32_t sessionId,const void * data,uint32_t dataLen)59 static void ScreenOnBytesReceived(int32_t sessionId, const void *data, uint32_t dataLen) {}
60
ScreenOnStreamReceived(int32_t sessionId,const StreamData * data,const StreamData * ext,const StreamFrameInfo * frameInfo)61 static void ScreenOnStreamReceived(int32_t sessionId, const StreamData *data, const StreamData *ext,
62 const StreamFrameInfo *frameInfo) {}
63
ScreenOnMessageReceived(int sessionId,const void * data,unsigned int dataLen)64 static void ScreenOnMessageReceived(int sessionId, const void *data, unsigned int dataLen) {}
65
66 /**
67 * @tc.name: CreateSoftbusSessionServer_001
68 * @tc.desc: Verify the CreateSoftbusSessionServer function.
69 * @tc.type: FUNC
70 * @tc.require: Issue Number
71 */
72 HWTEST_F(SoftbusAdapterTest, CreateSoftbusSessionServer_001, TestSize.Level1)
73 {
74 softbusAdapter_->sessListener_.OnBind = ScreenOnSoftbusSessionOpened;
75 softbusAdapter_->sessListener_.OnShutdown = ScreenOnSoftbusSessionClosed;
76 softbusAdapter_->sessListener_.OnBytes = ScreenOnBytesReceived;
77 softbusAdapter_->sessListener_.OnStream = ScreenOnStreamReceived;
78 softbusAdapter_->sessListener_.OnMessage = ScreenOnMessageReceived;
79
80 std::string pkgname = PKG_NAME;
81 std::string sessionName = DATA_SESSION_NAME;
82 std::string peerDevId = "peerDevId";
83 int32_t sessionId = 0;
84 void *data = nullptr;
85 uint32_t dataLen = 0;
86 StreamData sData;
87 sData.bufLen = 0;
88 sData.buf = reinterpret_cast<char*>(&dataLen);
89 StreamData *streamData = nullptr;
90 StreamData *ext = nullptr;
91 StreamFrameInfo *frameInfo = nullptr;
92 softbusAdapter_->OnBytesReceived(sessionId, data, dataLen);
93 softbusAdapter_->OnStreamReceived(sessionId, streamData, ext, frameInfo);
94 data = reinterpret_cast<void*>(&dataLen);
95 streamData = &sData;
96 softbusAdapter_->OnBytesReceived(sessionId, data, dataLen);
97 softbusAdapter_->OnStreamReceived(sessionId, streamData, ext, frameInfo);
98 dataLen = DSCREEN_MAX_RECV_DATA_LEN + 1;
99 sData.bufLen = DSCREEN_MAX_RECV_DATA_LEN + 1;
100 softbusAdapter_->OnBytesReceived(sessionId, data, dataLen);
101 softbusAdapter_->OnStreamReceived(sessionId, streamData, ext, frameInfo);
102 dataLen = 100;
103 sData.bufLen = 100;
104 softbusAdapter_->OnBytesReceived(sessionId, data, dataLen);
105 softbusAdapter_->OnStreamReceived(sessionId, streamData, ext, frameInfo);
106
107 std::shared_ptr<ISoftbusListener> listener = std::make_shared<MockSoftbusListener>();
108 softbusAdapter_->devId2SessIdMap_[sessionId] = "strListenerKey";
109 softbusAdapter_->mapListeners_["strListenerKey"] = listener;
110 softbusAdapter_->OnBytesReceived(sessionId, data, dataLen);
111 softbusAdapter_->OnStreamReceived(sessionId, streamData, ext, frameInfo);
112
113 int32_t actual = softbusAdapter_->CreateSoftbusSessionServer(pkgname, sessionName, peerDevId);
114 EXPECT_EQ(DH_SUCCESS, actual);
115 softbusAdapter_->RemoveSoftbusSessionServer(pkgname, sessionName, peerDevId);
116 }
117
118 /**
119 * @tc.name: CreateSoftbusSessionServer_002
120 * @tc.desc: Verify the CreateSoftbusSessionServer function.
121 * @tc.type: FUNC
122 * @tc.require: Issue Number
123 */
124 HWTEST_F(SoftbusAdapterTest, CreateSoftbusSessionServer_002, TestSize.Level1)
125 {
126 std::string pkgname = PKG_NAME;
127 std::string sessionName = DATA_SESSION_NAME;
128 std::string peerDevId = "peerDevId";
129 int32_t actual = softbusAdapter_->CreateSoftbusSessionServer(pkgname, sessionName, peerDevId);
130 EXPECT_EQ(DH_SUCCESS, actual);
131 softbusAdapter_->RemoveSoftbusSessionServer(pkgname, sessionName, peerDevId);
132 }
133
134 /**
135 * @tc.name: CreateSoftbusSessionServer_003
136 * @tc.desc: Verify the CreateSoftbusSessionServer function.
137 * @tc.type: FUNC
138 * @tc.require: Issue Number
139 */
140 HWTEST_F(SoftbusAdapterTest, CreateSoftbusSessionServer_003, TestSize.Level1)
141 {
142 std::string pkgName = "ohos.dhardware.dscreentest";
143 std::string sessionName = DATA_SESSION_NAME;
144 std::string peerDevId = "peerDevId";
145 softbusAdapter_->serverIdMap_.insert(std::make_pair(100000, sessionName + "_" + peerDevId));
146 int32_t actual = softbusAdapter_->CreateSoftbusSessionServer(pkgName, sessionName, peerDevId);
147 EXPECT_EQ(DH_SUCCESS, actual);
148 }
149
150 /**
151 * @tc.name: CreateSoftbusSessionServer_004
152 * @tc.desc: Verify the CreateSoftbusSessionServer function.
153 * @tc.type: FUNC
154 * @tc.require: Issue Number
155 */
156 HWTEST_F(SoftbusAdapterTest, CreateSoftbusSessionServer_004, TestSize.Level1)
157 {
158 std::string pkgName = PKG_NAME;
159 std::string sessionName = DATA_SESSION_NAME;
160 std::string peerDevId = "peerDevId";
161 g_mockListenReturnIntValue = -1;
162 softbusAdapter_->serverIdMap_.insert(std::make_pair(100000, "test"));
163 int32_t actual = softbusAdapter_->CreateSoftbusSessionServer(pkgName, sessionName, peerDevId);
164 EXPECT_EQ(ERR_DH_SCREEN_ADAPTER_BAD_VALUE, actual);
165
166 softbusAdapter_->serverIdMap_.clear();
167 g_mockSocketReturnIntValue = -1;
168 actual = softbusAdapter_->CreateSoftbusSessionServer(pkgName, sessionName, peerDevId);
169 EXPECT_EQ(ERR_DH_SCREEN_ADAPTER_BAD_VALUE, actual);
170 softbusAdapter_->RemoveSoftbusSessionServer(pkgName, sessionName, peerDevId);
171 }
172
173 /**
174 * @tc.name: RegisterSoftbusListener_001
175 * @tc.desc: Verify the RegisterSoftbusListener function.
176 * @tc.type: FUNC
177 * @tc.require: Issue Number
178 */
179 HWTEST_F(SoftbusAdapterTest, RegisterSoftbusListener_001, TestSize.Level1)
180 {
181 std::shared_ptr<ISoftbusListener> listener = std::make_shared<MockSoftbusListener>();
182 std::string sessionName = DATA_SESSION_NAME;
183 std::string peerDevId = "testDevId";
184
185 int32_t actual = softbusAdapter_->RegisterSoftbusListener(listener, sessionName, peerDevId);
186 EXPECT_EQ(DH_SUCCESS, actual);
187
188 actual = softbusAdapter_->UnRegisterSoftbusListener(sessionName, peerDevId);
189 EXPECT_EQ(DH_SUCCESS, actual);
190 }
191
192 /**
193 * @tc.name: RegisterSoftbusListener_002
194 * @tc.desc: Verify the RegisterSoftbusListener function.
195 * @tc.type: FUNC
196 * @tc.require: Issue Number
197 */
198 HWTEST_F(SoftbusAdapterTest, RegisterSoftbusListener_002, TestSize.Level1)
199 {
200 std::shared_ptr<ISoftbusListener> listener = std::make_shared<MockSoftbusListener>();
201 std::string sessionName = DATA_SESSION_NAME;
202 std::string peerDevId = "testDevId";
203
204 int32_t actual = softbusAdapter_->RegisterSoftbusListener(listener, sessionName, peerDevId);
205 EXPECT_EQ(DH_SUCCESS, actual);
206
207 actual = softbusAdapter_->RegisterSoftbusListener(listener, sessionName, peerDevId);
208 EXPECT_EQ(ERR_DH_SCREEN_ADAPTER_REGISTER_SOFTBUS_LISTENER_FAIL, actual);
209 }
210
211 /**
212 * @tc.name: RegisterSoftbusListener_003
213 * @tc.desc: Verify the RegisterSoftbusListener function.
214 * @tc.type: FUNC
215 * @tc.require: Issue Number
216 */
217 HWTEST_F(SoftbusAdapterTest, RegisterSoftbusListener_003, TestSize.Level1)
218 {
219 std::shared_ptr<ISoftbusListener> listener = nullptr;
220 std::string sessionName = DATA_SESSION_NAME;
221 std::string peerDevId = "testDevId";
222
223 int32_t actual = softbusAdapter_->RegisterSoftbusListener(listener, sessionName, peerDevId);
224 EXPECT_EQ(ERR_DH_SCREEN_ADAPTER_REGISTER_SOFTBUS_LISTENER_FAIL, actual);
225 }
226
227 /**
228 * @tc.name: UnRegisterSoftbusListener_001
229 * @tc.desc: Verify the UnRegisterSoftbusListener function.
230 * @tc.type: FUNC
231 * @tc.require: Issue Number
232 */
233 HWTEST_F(SoftbusAdapterTest, UnRegisterSoftbusListener_001, TestSize.Level1)
234 {
235 std::string sessionName = DATA_SESSION_NAME;
236 std::string peerDevId = "testDevId";
237
238 int32_t actual = softbusAdapter_->UnRegisterSoftbusListener(sessionName, peerDevId);
239
240 EXPECT_EQ(DH_SUCCESS, actual);
241 }
242
243 /**
244 * @tc.name: RemoveSoftbusSessionServer_001
245 * @tc.desc: Verify the RemoveSoftbusSessionServer function.
246 * @tc.type: FUNC
247 * @tc.require: Issue Number
248 */
249 HWTEST_F(SoftbusAdapterTest, RemoveSoftbusSessionServer_001, TestSize.Level1)
250 {
251 std::string pkgname = "";
252 std::string sessionName = "";
253 std::string peerDevId = "";
254
255 int32_t actual = softbusAdapter_->RemoveSoftbusSessionServer(pkgname, sessionName, peerDevId);
256 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
257
258 sessionName = "sessionName";
259 actual = softbusAdapter_->RemoveSoftbusSessionServer(pkgname, sessionName, peerDevId);
260 EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
261 }
262
263 /**
264 * @tc.name: RemoveSoftbusSessionServer_002
265 * @tc.desc: Verify the RemoveSoftbusSessionServer function.
266 * @tc.type: FUNC
267 * @tc.require: Issue Number
268 */
269 HWTEST_F(SoftbusAdapterTest, RemoveSoftbusSessionServer_002, TestSize.Level1)
270 {
271 std::string pkgname = PKG_NAME;
272 std::string sessionName = DATA_SESSION_NAME;
273 std::string peerDevId = "peerDevId";
274
275 int32_t actual = softbusAdapter_->RemoveSoftbusSessionServer(pkgname, sessionName, peerDevId);
276 EXPECT_EQ(DH_SUCCESS, actual);
277 }
278
279 /**
280 * @tc.name: OpenSoftbusSession_001
281 * @tc.desc: Verify the OpenSoftbusSession function.
282 * @tc.type: FUNC
283 * @tc.require: Issue Number
284 */
285 HWTEST_F(SoftbusAdapterTest, OpenSoftbusSession_001, TestSize.Level1)
286 {
287 std::string mySessionName = DATA_SESSION_NAME;
288 std::string peerSessionName = DATA_SESSION_NAME;
289 std::string peerDevId = "testDevId";
290 int32_t actual = softbusAdapter_->OpenSoftbusSession(mySessionName, peerSessionName, peerDevId);
291 EXPECT_NE(DH_SUCCESS, actual);
292
293 g_mockBindReturnIntValue = -1;
294 actual = softbusAdapter_->OpenSoftbusSession(mySessionName, peerSessionName, peerDevId);
295 EXPECT_EQ(ERR_DH_SCREEN_ADAPTER_PARA_ERROR, actual);
296
297 g_mockSocketReturnIntValue = -1;
298 actual = softbusAdapter_->OpenSoftbusSession(mySessionName, peerSessionName, peerDevId);
299 EXPECT_EQ(ERR_DH_SCREEN_ADAPTER_PARA_ERROR, actual);
300 }
301
302 /**
303 * @tc.name: CloseSoftbusSession_001
304 * @tc.desc: Verify the CloseSoftbusSession function.
305 * @tc.type: FUNC
306 * @tc.require: Issue Number
307 */
308 HWTEST_F(SoftbusAdapterTest, CloseSoftbusSession_001, TestSize.Level1)
309 {
310 int32_t actual = softbusAdapter_->CloseSoftbusSession(0);
311 EXPECT_EQ(DH_SUCCESS, actual);
312 }
313
314 /**
315 * @tc.name: SendSoftbusBytes_001
316 * @tc.desc: Verify the SendSoftbusBytes function.
317 * @tc.type: FUNC
318 * @tc.require: Issue Number
319 */
320 HWTEST_F(SoftbusAdapterTest, SendSoftbusBytes_001, TestSize.Level1)
321 {
322 int32_t sessionId = 0;
323 void *data = nullptr;
324 int32_t dataLen = 0;
325 int32_t actual = softbusAdapter_->SendSoftbusBytes(sessionId, data, dataLen);
326 EXPECT_EQ(DH_SUCCESS, actual);
327
328 g_mockSendBytesReturnIntValue = -1;
329 actual = softbusAdapter_->SendSoftbusBytes(sessionId, data, dataLen);
330 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ERROR, actual);
331 }
332
333 /**
334 * @tc.name: SendSoftbusStream_001
335 * @tc.desc: Verify the SendSoftbusStream function.
336 * @tc.type: FUNC
337 * @tc.require: Issue Number
338 */
339 HWTEST_F(SoftbusAdapterTest, SendSoftbusStream_001, TestSize.Level1)
340 {
341 int32_t sessionId = 0;
342 StreamData *data = nullptr;
343 StreamData *ext = nullptr;
344 StreamFrameInfo *param = nullptr;
345 int32_t actual = softbusAdapter_->SendSoftbusStream(sessionId, data, ext, param);
346 EXPECT_EQ(DH_SUCCESS, actual);
347 }
348
349 /**
350 * @tc.name: OnSoftbusSessionOpened_001
351 * @tc.desc: Verify the OnSoftbusSessionOpened function.
352 * @tc.type: FUNC
353 * @tc.require: Issue Number
354 */
355 HWTEST_F(SoftbusAdapterTest, OnSoftbusSessionOpened_001, TestSize.Level1)
356 {
357 PeerSocketInfo peerSocketInfo = {
358 .name = const_cast<char*>(PEER_SESSION_NAME.c_str()),
359 .networkId = const_cast<char*>(REMOTE_DEV_ID.c_str()),
360 .pkgName = const_cast<char*>(DSCREEN_PKG_NAME_TEST.c_str()),
361 .dataType = DATA_TYPE_BYTES
362 };
363 int32_t actual = softbusAdapter_->OnSoftbusSessionOpened(0, peerSocketInfo);
364 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ERROR, actual);
365 }
366
367 /**
368 * @tc.name: OnSoftbusSessionOpened_002
369 * @tc.desc: Verify the OnSoftbusSessionOpened function.
370 * @tc.type: FUNC
371 * @tc.require: Issue Number
372 */
373 HWTEST_F(SoftbusAdapterTest, OnSoftbusSessionOpened_002, TestSize.Level1)
374 {
375 PeerSocketInfo peerSocketInfo = {
376 .name = const_cast<char*>(PEER_SESSION_NAME.c_str()),
377 .networkId = nullptr,
378 .pkgName = const_cast<char*>(DSCREEN_PKG_NAME_TEST.c_str()),
379 .dataType = DATA_TYPE_BYTES
380 };
381 std::string pkgName = "ohos.dhardware.dscreentest";
382 std::string sessionName = DATA_SESSION_NAME;
383 std::string peerDevId = "peerDevId";
384 softbusAdapter_->serverIdMap_.insert(std::make_pair(100000, sessionName + "_" + peerDevId));
385
386 int32_t sessionId = 0;
387 std::shared_ptr<ISoftbusListener> listener = std::make_shared<MockSoftbusListener>();
388 softbusAdapter_->devId2SessIdMap_[sessionId] = "strListenerKey";
389 softbusAdapter_->mapListeners_["strListenerKey"] = listener;
390
391 int32_t actual = softbusAdapter_->OnSoftbusSessionOpened(sessionId, peerSocketInfo);
392 EXPECT_EQ(DH_SUCCESS, actual);
393 }
394
395 /**
396 * @tc.name: OnSoftbusSessionOpened_003
397 * @tc.desc: Verify the OnSoftbusSessionOpened function.
398 * @tc.type: FUNC
399 * @tc.require: Issue Number
400 */
401 HWTEST_F(SoftbusAdapterTest, OnSoftbusSessionOpened_003, TestSize.Level1)
402 {
403 PeerSocketInfo peerSocketInfo = {
404 .name = const_cast<char*>(PEER_SESSION_NAME.c_str()),
405 .networkId = const_cast<char*>(REMOTE_DEV_ID.c_str()),
406 .pkgName = const_cast<char*>(DSCREEN_PKG_NAME_TEST.c_str()),
407 .dataType = DATA_TYPE_BYTES
408 };
409 softbusAdapter_->serverIdMap_.insert(std::make_pair(100000, REMOTE_DEV_ID));
410 int32_t actual = softbusAdapter_->OnSoftbusSessionOpened(0, peerSocketInfo);
411 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ERROR, actual);
412 }
413
414 /**
415 * @tc.name: OnSoftbusSessionOpened_004
416 * @tc.desc: Verify the OnSoftbusSessionOpened function.
417 * @tc.type: FUNC
418 * @tc.require: Issue Number
419 */
420 HWTEST_F(SoftbusAdapterTest, OnSoftbusSessionOpened_004, TestSize.Level1)
421 {
422 PeerSocketInfo peerSocketInfo = {
423 .name = const_cast<char*>(PEER_SESSION_NAME.c_str()),
424 .networkId = const_cast<char*>(REMOTE_DEV_ID.c_str()),
425 .pkgName = const_cast<char*>(DSCREEN_PKG_NAME_TEST.c_str()),
426 .dataType = DATA_TYPE_BYTES
427 };
428 softbusAdapter_->serverIdMap_.insert(std::make_pair(100000, "not exist id"));
429 int32_t actual = softbusAdapter_->OnSoftbusSessionOpened(0, peerSocketInfo);
430 EXPECT_EQ(ERR_DH_SCREEN_TRANS_ERROR, actual);
431 }
432
433 /**
434 * @tc.name: OnSoftbusSessionClosed_001
435 * @tc.desc: Verify the OnSoftbusSessionClosed function.
436 * @tc.type: FUNC
437 * @tc.require: Issue Number
438 */
439 HWTEST_F(SoftbusAdapterTest, OnSoftbusSessionClosed_001, TestSize.Level1)
440 {
441 int32_t sessionId = 0;
442 ShutdownReason reason = SHUTDOWN_REASON_UNKNOWN;
443 softbusAdapter_->mapSessListeners_[sessionId] = nullptr;
444 softbusAdapter_->OnSoftbusSessionClosed(sessionId, reason);
445 EXPECT_TRUE(softbusAdapter_->mapSessListeners_.size() > 0);
446 }
447
448 /**
449 * @tc.name: OnSoftbusSessionClosed_002
450 * @tc.desc: Verify the OnSoftbusSessionClosed function.
451 * @tc.type: FUNC
452 * @tc.require: Issue Number
453 */
454 HWTEST_F(SoftbusAdapterTest, OnSoftbusSessionClosed_002, TestSize.Level1)
455 {
456 int32_t sessionId = 0;
457 ShutdownReason reason = SHUTDOWN_REASON_UNKNOWN;
458 std::shared_ptr<ISoftbusListener> listener = std::make_shared<MockSoftbusListener>();
459 softbusAdapter_->mapSessListeners_[sessionId] = listener;
460 softbusAdapter_->OnSoftbusSessionClosed(sessionId, reason);
461 EXPECT_TRUE(softbusAdapter_->mapSessListeners_.size() == 0);
462 }
463
464 /**
465 * @tc.name: GetSoftbusListenerByName_001
466 * @tc.desc: Verify the GetSoftbusListenerByName function.
467 * @tc.type: FUNC
468 * @tc.require: Issue Number
469 */
470 HWTEST_F(SoftbusAdapterTest, GetSoftbusListenerByName_001, TestSize.Level1)
471 {
472 int32_t sessionId = 0;
473 softbusAdapter_->devId2SessIdMap_[sessionId] = "test";
474 std::shared_ptr<ISoftbusListener> listener = softbusAdapter_->GetSoftbusListenerByName(sessionId);
475 EXPECT_EQ(nullptr, listener);
476 }
477
478 /**
479 * @tc.name: GetSoftbusListenerByName_002
480 * @tc.desc: Verify the GetSoftbusListenerByName function.
481 * @tc.type: FUNC
482 * @tc.require: Issue Number
483 */
484 HWTEST_F(SoftbusAdapterTest, GetSoftbusListenerByName_002, TestSize.Level1)
485 {
486 int32_t sessionId = 0;
487 softbusAdapter_->devId2SessIdMap_[sessionId + 1] = "test";
488 std::shared_ptr<ISoftbusListener> listener = softbusAdapter_->GetSoftbusListenerByName(sessionId);
489 EXPECT_EQ(nullptr, listener);
490 }
491
492 /**
493 * @tc.name: GetSoftbusListenerByName_003
494 * @tc.desc: Verify the GetSoftbusListenerByName function.
495 * @tc.type: FUNC
496 * @tc.require: Issue Number
497 */
498 HWTEST_F(SoftbusAdapterTest, GetSoftbusListenerByName_003, TestSize.Level1)
499 {
500 int32_t sessionId = 0;
501 std::shared_ptr<ISoftbusListener> listener = std::make_shared<MockSoftbusListener>();
502 softbusAdapter_->devId2SessIdMap_[sessionId] = "strListenerKey";
503 softbusAdapter_->mapListeners_["strListenerKey"] = listener;
504 std::shared_ptr<ISoftbusListener> mapListener = softbusAdapter_->GetSoftbusListenerByName(sessionId);
505 EXPECT_NE(nullptr, mapListener);
506 }
507
508 /**
509 * @tc.name: GetSoftbusListenerById_001
510 * @tc.desc: Verify the GetSoftbusListenerById function.
511 * @tc.type: FUNC
512 * @tc.require: Issue Number
513 */
514 HWTEST_F(SoftbusAdapterTest, GetSoftbusListenerById_001, TestSize.Level1)
515 {
516 int32_t sessionId = 0;
517 softbusAdapter_->mapSessListeners_[sessionId] = nullptr;
518 std::shared_ptr<ISoftbusListener> listener = softbusAdapter_->GetSoftbusListenerById(sessionId);
519 EXPECT_EQ(nullptr, listener);
520 }
521
522 /**
523 * @tc.name: GetSoftbusListenerById_002
524 * @tc.desc: Verify the GetSoftbusListenerById function.
525 * @tc.type: FUNC
526 * @tc.require: Issue Number
527 */
528 HWTEST_F(SoftbusAdapterTest, GetSoftbusListenerById_002, TestSize.Level1)
529 {
530 int32_t sessionId = 0;
531 SessionInfo sessionInfo;
532 sessionInfo.sessionName = "hello";
533 sessionInfo.peerDevId = "world";
534 std::shared_ptr<ISoftbusListener> listener = nullptr;
535 softbusAdapter_->mapListeners_["hello_world"] = listener;
536 std::shared_ptr<ISoftbusListener> actual = softbusAdapter_->GetSoftbusListenerById(sessionId);
537 EXPECT_EQ(nullptr, actual);
538 }
539 } // DistributedHardware
540 } // OHOS
541
Socket(SocketInfo info)542 extern "C" __attribute__((constructor)) int Socket(SocketInfo info)
543 {
544 return g_mockSocketReturnIntValue;
545 }
546
Bind(int32_t socket,const QosTV qos[],uint32_t qosCount,const ISocketListener * listener)547 extern "C" __attribute__((constructor)) int Bind(int32_t socket, const QosTV qos[], uint32_t qosCount,
548 const ISocketListener *listener)
549 {
550 return g_mockBindReturnIntValue;
551 }
552
Listen(int32_t socket,const QosTV qos[],uint32_t qosCount,const ISocketListener * listener)553 extern "C" __attribute__((constructor)) int Listen(int32_t socket, const QosTV qos[], uint32_t qosCount,
554 const ISocketListener *listener)
555 {
556 return g_mockListenReturnIntValue;
557 }
558
SendBytes(int32_t socket,const void * data,uint32_t len)559 extern "C" __attribute__((constructor)) int SendBytes(int32_t socket, const void *data, uint32_t len)
560 {
561 return g_mockSendBytesReturnIntValue;
562 }
563
Shutdown(int32_t socket)564 extern "C" __attribute__((constructor)) void Shutdown(int32_t socket) {}
565
SendStream(int32_t socket,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)566 extern "C" __attribute__((constructor)) int SendStream(int32_t socket, const StreamData *data, const StreamData *ext,
567 const StreamFrameInfo *param)
568 {
569 return g_mockSendStreamReturnIntValue;
570 }
571