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