1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "dbinder_service.h"
17 #include "gtest/gtest.h"
18 #include "rpc_log.h"
19 #include "log_tags.h"
20 #define private public
21 #include "dbinder_remote_listener.h"
22 #undef private
23
24 using namespace testing::ext;
25 using namespace OHOS;
26 using namespace OHOS::HiviewDFX;
27
28 class DBinderRemoteListenerUnitTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
32 void SetUp();
33 void TearDown();
34 const std::string NETWORKID_TEST = "123456789";
35 static constexpr HiLogLabel LABEL = { LOG_CORE, LOG_ID_TEST, "DBinderRemoteListenerUnitTest" };
36 };
37
SetUp()38 void DBinderRemoteListenerUnitTest::SetUp() {}
39
TearDown()40 void DBinderRemoteListenerUnitTest::TearDown() {}
41
SetUpTestCase()42 void DBinderRemoteListenerUnitTest::SetUpTestCase() {}
43
TearDownTestCase()44 void DBinderRemoteListenerUnitTest::TearDownTestCase() {}
45
46 /**
47 * @tc.name: CreateClientSocket_001
48 * @tc.desc: Verify CreateClientSocket function when networkId is empty.
49 * @tc.type: FUNC
50 */
51 HWTEST_F(DBinderRemoteListenerUnitTest, CreateClientSocket_001, TestSize.Level1)
52 {
53 DBinderRemoteListener dBinderRemoteListener;
54 std::string networkId = "";
55 EXPECT_EQ(dBinderRemoteListener.CreateClientSocket(networkId), SOCKET_ID_INVALID);
56 }
57
58 /**
59 * @tc.name: CreateClientSocket_002
60 * @tc.desc: Verify CreateClientSocket function when networkId is empty.
61 * @tc.type: FUNC
62 */
63 HWTEST_F(DBinderRemoteListenerUnitTest, CreateClientSocket_002, TestSize.Level1)
64 {
65 DBinderRemoteListener dBinderRemoteListener;
66 std::string networkId = "networkIdTest";
67 EXPECT_EQ(dBinderRemoteListener.CreateClientSocket(networkId), SOCKET_ID_INVALID);
68 }
69
70
71 /**
72 * @tc.name: ServerOnBind_001
73 * @tc.desc: Verify ServerOnBind function when binding a valid socket.
74 * @tc.type: FUNC
75 */
76 HWTEST_F(DBinderRemoteListenerUnitTest, ServerOnBind_001, TestSize.Level1)
77 {
78 DBinderRemoteListener dBinderRemoteListener;
79 int32_t socketId = 1;
80 PeerSocketInfo info = {
81 .networkId = const_cast<char *>(NETWORKID_TEST.c_str()),
82 };
83
84 dBinderRemoteListener.ServerOnBind(socketId, info);
85 EXPECT_EQ(dBinderRemoteListener.serverSocketInfos_.size(), 1);
86 dBinderRemoteListener.serverSocketInfos_.clear();
87 }
88
89 /**
90 * @tc.name: ServerOnBind_002
91 * @tc.desc: Verify ServerOnBind function when binding a valid socket.
92 * @tc.type: FUNC
93 */
94 HWTEST_F(DBinderRemoteListenerUnitTest, ServerOnBind_002, TestSize.Level1)
95 {
96 DBinderRemoteListener dBinderRemoteListener;
97 int32_t socketId = -1;
98 PeerSocketInfo info = {
99 .networkId = const_cast<char *>(NETWORKID_TEST.c_str()),
100 };
101
102 dBinderRemoteListener.ServerOnBind(socketId, info);
103 EXPECT_EQ(dBinderRemoteListener.serverSocketInfos_.size(), 1);
104 dBinderRemoteListener.serverSocketInfos_.clear();
105 }
106
107 /**
108 * @tc.name: ServerOnBind_003
109 * @tc.desc: Verify ServerOnBind function when binding a valid socket.
110 * @tc.type: FUNC
111 */
112 HWTEST_F(DBinderRemoteListenerUnitTest, ServerOnBind_003, TestSize.Level1)
113 {
114 DBinderRemoteListener dBinderRemoteListener;
115 int32_t socketId = INT_MAX;
116 PeerSocketInfo info = {
117 .networkId = const_cast<char *>(NETWORKID_TEST.c_str()),
118 };
119
120 dBinderRemoteListener.ServerOnBind(socketId, info);
121 EXPECT_EQ(dBinderRemoteListener.serverSocketInfos_.size(), 1);
122 dBinderRemoteListener.serverSocketInfos_.clear();
123 }
124
125 /**
126 * @tc.name: ServerOnShutdown_001
127 * @tc.desc: Verify ServerOnShutdown function when shutdown occurs for an existing socket.
128 * @tc.type: FUNC
129 */
130 HWTEST_F(DBinderRemoteListenerUnitTest, ServerOnShutdown_001, TestSize.Level1)
131 {
132 DBinderRemoteListener dBinderRemoteListener;
133 std::string networkId = NETWORKID_TEST;
134 int32_t socketId = 1;
135 dBinderRemoteListener.serverSocketInfos_[networkId] = socketId;
136 dBinderRemoteListener.ServerOnShutdown(socketId, SHUTDOWN_REASON_PEER);
137 EXPECT_EQ(dBinderRemoteListener.serverSocketInfos_.size(), 0);
138 }
139
140 /**
141 * @tc.name: ServerOnShutdown_002
142 * @tc.desc: Verify ServerOnShutdown function when shutdown occurs for a non-existing socket.
143 * @tc.type: FUNC
144 */
145 HWTEST_F(DBinderRemoteListenerUnitTest, ServerOnShutdown_002, TestSize.Level1)
146 {
147 DBinderRemoteListener dBinderRemoteListener;
148 int32_t socketId = 1;
149 dBinderRemoteListener.ServerOnShutdown(socketId, SHUTDOWN_REASON_PEER);
150 EXPECT_EQ(dBinderRemoteListener.serverSocketInfos_.size(), 0);
151 }
152
153 /**
154 * @tc.name: ServerOnShutdown_003
155 * @tc.desc: Verify ServerOnShutdown function when shutdown occurs for an existing socket.
156 * @tc.type: FUNC
157 */
158 HWTEST_F(DBinderRemoteListenerUnitTest, ServerOnShutdown_003, TestSize.Level1)
159 {
160 DBinderRemoteListener dBinderRemoteListener;
161 std::string networkId = NETWORKID_TEST;
162 int32_t socketId = -1;
163 dBinderRemoteListener.serverSocketInfos_[networkId] = socketId;
164 dBinderRemoteListener.ServerOnShutdown(socketId, SHUTDOWN_REASON_PEER);
165 EXPECT_EQ(dBinderRemoteListener.serverSocketInfos_.size(), 0);
166 }
167
168 /**
169 * @tc.name: ServerOnShutdown_004
170 * @tc.desc: Verify ServerOnShutdown function when shutdown occurs for a non-existing socket.
171 * @tc.type: FUNC
172 */
173 HWTEST_F(DBinderRemoteListenerUnitTest, ServerOnShutdown_004, TestSize.Level1)
174 {
175 DBinderRemoteListener dBinderRemoteListener;
176 int32_t socketId = -1;
177 dBinderRemoteListener.ServerOnShutdown(socketId, SHUTDOWN_REASON_PEER);
178 EXPECT_EQ(dBinderRemoteListener.serverSocketInfos_.size(), 0);
179 }
180
181 /**
182 * @tc.name: OnBytesReceived_001
183 * @tc.desc: Verify OnBytesReceived function when data is nullptr.
184 * @tc.type: FUNC
185 */
186 HWTEST_F(DBinderRemoteListenerUnitTest, OnBytesReceived_001, TestSize.Level1)
187 {
188 DBinderRemoteListener dBinderRemoteListener;
189 const char* data = nullptr;
190 auto len = sizeof(struct DHandleEntryTxRx);
191 int32_t socketId = 1;
192 dBinderRemoteListener.OnBytesReceived(socketId, data, len);
193 EXPECT_EQ(data, nullptr);
194 }
195
196 /**
197 * @tc.name: OnBytesReceived_002
198 * @tc.desc: Verify OnBytesReceived function when data length is zero.
199 * @tc.type: FUNC
200 */
201 HWTEST_F(DBinderRemoteListenerUnitTest, OnBytesReceived_002, TestSize.Level1)
202 {
203 DBinderRemoteListener dBinderRemoteListener;
204 const char *data = "testdatas";
205 ssize_t len = 0;
206 int32_t socketId = 1;
207 dBinderRemoteListener.OnBytesReceived(socketId, data, len);
208 EXPECT_EQ(len < static_cast<ssize_t>(sizeof(struct DHandleEntryTxRx)), true);
209 }
210
211 /**
212 * @tc.name: OnBytesReceived_003
213 * @tc.desc: Verify OnBytesReceived function when data is nullptr and length is valid.
214 * @tc.type: FUNC
215 */
216 HWTEST_F(DBinderRemoteListenerUnitTest, OnBytesReceived_003, TestSize.Level1)
217 {
218 DBinderRemoteListener dBinderRemoteListener;
219 auto len = sizeof(struct DHandleEntryTxRx);
220 dBinderRemoteListener.OnBytesReceived(1, nullptr, len);
221 EXPECT_EQ(dBinderRemoteListener.listenSocketId_, SOCKET_ID_INVALID);
222 }
223
224 /**
225 * @tc.name: OnBytesReceived_004
226 * @tc.desc: Verify OnBytesReceived function when data length is less than required size.
227 * @tc.type: FUNC
228 */
229 HWTEST_F(DBinderRemoteListenerUnitTest, OnBytesReceived_004, TestSize.Level1)
230 {
231 DBinderRemoteListener dBinderRemoteListener;
232 const char *data = "testdata";
233 uint32_t len = sizeof(struct DHandleEntryTxRx) - 1;
234 int32_t socketId = 1;
235 dBinderRemoteListener.OnBytesReceived(socketId, data, len);
236 EXPECT_EQ(len != sizeof(struct DHandleEntryTxRx), true);
237 }
238
239 /**
240 * @tc.name: OnBytesReceived_005
241 * @tc.desc: Verify OnBytesReceived function when data length and content are valid.
242 * @tc.type: FUNC
243 */
244 HWTEST_F(DBinderRemoteListenerUnitTest, OnBytesReceived_005, TestSize.Level1)
245 {
246 DBinderRemoteListener dBinderRemoteListener;
247 DHandleEntryTxRx data;
248 data.head.len = sizeof(DHandleEntryTxRx);
249 uint32_t len = sizeof(DHandleEntryTxRx);
250 int32_t socketId = 1;
251 dBinderRemoteListener.OnBytesReceived(socketId, &data, len);
252 EXPECT_EQ(dBinderRemoteListener.listenSocketId_, SOCKET_ID_INVALID);
253 }
254
255 /**
256 * @tc.name: OnBytesReceived_006
257 * @tc.desc: Verify OnBytesReceived function when data is nullptr and length is Invalid.
258 * @tc.type: FUNC
259 */
260 HWTEST_F(DBinderRemoteListenerUnitTest, OnBytesReceived_006, TestSize.Level1)
261 {
262 DBinderRemoteListener dBinderRemoteListener;
263 auto len = 0;
264 dBinderRemoteListener.OnBytesReceived(1, nullptr, len);
265 EXPECT_EQ(dBinderRemoteListener.listenSocketId_, SOCKET_ID_INVALID);
266 }
267
268 /**
269 * @tc.name: OnBytesReceived_007
270 * @tc.desc: Verify OnBytesReceived function when socketid is invalid.
271 * @tc.type: FUNC
272 */
273 HWTEST_F(DBinderRemoteListenerUnitTest, OnBytesReceived_007, TestSize.Level1)
274 {
275 DBinderRemoteListener dBinderRemoteListener;
276 const char *data = "testdatas";
277 ssize_t len = 10;
278 int32_t socketId = -1;
279 dBinderRemoteListener.OnBytesReceived(socketId, data, len);
280 EXPECT_EQ(len < static_cast<ssize_t>(sizeof(struct DHandleEntryTxRx)), true);
281 }
282
283 /**
284 * @tc.name: SendDataToRemote_001
285 * @tc.desc: Verify SendDataToRemote function when message is nullptr.
286 * @tc.type: FUNC
287 */
288 HWTEST_F(DBinderRemoteListenerUnitTest, SendDataToRemote_001, TestSize.Level1)
289 {
290 DBinderRemoteListener dBinderRemoteListener;
291 const std::string deviceId = "testdeviceid";
292 EXPECT_EQ(dBinderRemoteListener.SendDataToRemote(deviceId, nullptr), false);
293 }
294
295 /**
296 * @tc.name: SendDataToRemote_002
297 * @tc.desc: Verify SendDataToRemote function when deviceId is empty.
298 * @tc.type: FUNC
299 */
300 HWTEST_F(DBinderRemoteListenerUnitTest, SendDataToRemote_002, TestSize.Level1)
301 {
302 DBinderRemoteListener dBinderRemoteListener;
303 const std::string deviceId = "";
304 DHandleEntryTxRx message;
305 message.head.len = sizeof(DHandleEntryTxRx);
306 EXPECT_EQ(dBinderRemoteListener.SendDataToRemote(deviceId, &message), false);
307 }
308
309 /**
310 * @tc.name: SendDataToRemote_003
311 * @tc.desc: Verify SendDataToRemote function when deviceId is invalid.
312 * @tc.type: FUNC
313 */
314 HWTEST_F(DBinderRemoteListenerUnitTest, SendDataToRemote_003, TestSize.Level1)
315 {
316 DBinderRemoteListener dBinderRemoteListener;
317 const std::string deviceId = "123";
318 DHandleEntryTxRx message;
319 message.head.len = sizeof(DHandleEntryTxRx);
320 EXPECT_EQ(dBinderRemoteListener.SendDataToRemote(deviceId, &message), false);
321 }
322
323 /**
324 * @tc.name: StartListener_001
325 * @tc.desc: Verify StartListener function.
326 * @tc.type: FUNC
327 */
328 HWTEST_F(DBinderRemoteListenerUnitTest, StartListener_001, TestSize.Level1)
329 {
330 DBinderRemoteListener dBinderRemoteListener;
331 EXPECT_EQ(dBinderRemoteListener.StartListener(), false);
332 }
333
334 /**
335 * @tc.name: StopListener_001
336 * @tc.desc: Verify StopListener function.
337 * @tc.type: FUNC
338 */
339 HWTEST_F(DBinderRemoteListenerUnitTest, StopListener_001, TestSize.Level1)
340 {
341 DBinderRemoteListener dBinderRemoteListener;
342 EXPECT_EQ(dBinderRemoteListener.StopListener(), true);
343 }
344
345 /**
346 * @tc.name: ShutdownSocket_001
347 * @tc.desc: Verify ShutdownSocket function when deviceId is empty.
348 * @tc.type: FUNC
349 */
350 HWTEST_F(DBinderRemoteListenerUnitTest, ShutdownSocket_001, TestSize.Level1)
351 {
352 DBinderRemoteListener dBinderRemoteListener;
353 const std::string deviceId = "";
354 EXPECT_EQ(dBinderRemoteListener.ShutdownSocket(deviceId), false);
355 }
356
357 /**
358 * @tc.name: ShutdownSocket_002
359 * @tc.desc: Verify ShutdownSocket function.
360 * @tc.type: FUNC
361 */
362 HWTEST_F(DBinderRemoteListenerUnitTest, ShutdownSocket_002, TestSize.Level1)
363 {
364 DBinderRemoteListener dBinderRemoteListener;
365 std::string networkId = NETWORKID_TEST;
366 int32_t socketId = 123;
367 dBinderRemoteListener.clientSocketInfos_[networkId] = socketId;
368 EXPECT_TRUE(dBinderRemoteListener.ShutdownSocket(networkId));
369 }
370
371 /**
372 * @tc.name: ShutdownSocket_003
373 * @tc.desc: Verify ShutdownSocket function when clientSocketInfo is empty.
374 * @tc.type: FUNC
375 */
376 HWTEST_F(DBinderRemoteListenerUnitTest, ShutdownSocket_003, TestSize.Level1)
377 {
378 DBinderRemoteListener dBinderRemoteListener;
379 const std::string networkId = NETWORKID_TEST;
380 EXPECT_EQ(dBinderRemoteListener.ShutdownSocket(networkId), false);
381 }
382
383 /**
384 * @tc.name: QueryOrNewDeviceLock_001
385 * @tc.desc: Verify QueryOrNewDeviceLock function.
386 * @tc.type: FUNC
387 */
388 HWTEST_F(DBinderRemoteListenerUnitTest, QueryOrNewDeviceLock_001, TestSize.Level1)
389 {
390 DBinderRemoteListener dBinderRemoteListener;
391 const std::string deviceId = "";
392 dBinderRemoteListener.QueryOrNewDeviceLock(deviceId);
393 const std::string deviceId1 = "123456";
394 std::shared_ptr<DeviceLock> lockInfo = nullptr;
395 lockInfo = dBinderRemoteListener.QueryOrNewDeviceLock(deviceId1);
396 EXPECT_TRUE(lockInfo != nullptr);
397 }
398
399 /**
400 * @tc.name: QueryOrNewDeviceLock_002
401 * @tc.desc: Verify QueryOrNewDeviceLock function.
402 * @tc.type: FUNC
403 */
404 HWTEST_F(DBinderRemoteListenerUnitTest, QueryOrNewDeviceLock_002, TestSize.Level1)
405 {
406 DBinderRemoteListener dBinderRemoteListener;
407 const std::string networkId = NETWORKID_TEST;
408 std::shared_ptr<DeviceLock> lockInfo = std::make_shared<struct DeviceLock>();
409 EXPECT_TRUE(lockInfo != nullptr);
410 dBinderRemoteListener.deviceLockMap_[networkId] = lockInfo;
411 EXPECT_EQ(dBinderRemoteListener.QueryOrNewDeviceLock(networkId), lockInfo);
412 }
413
414 /**
415 * @tc.name: SendDataReply_001
416 * @tc.desc: Verify SendDataReply function when message is nullptr.
417 * @tc.type: FUNC
418 */
419 HWTEST_F(DBinderRemoteListenerUnitTest, SendDataReply_001, TestSize.Level1)
420 {
421 DBinderRemoteListener dBinderRemoteListener;
422 const std::string deviceId = "";
423 EXPECT_EQ(dBinderRemoteListener.SendDataReply(deviceId, nullptr), false);
424 }
425
426 /**
427 * @tc.name: SendDataReply_002
428 * @tc.desc: Verify SendDataReply function when message has valid data.
429 * @tc.type: FUNC
430 */
431 HWTEST_F(DBinderRemoteListenerUnitTest, SendDataReply_002, TestSize.Level1)
432 {
433 DBinderRemoteListener dBinderRemoteListener;
434 const std::string deviceId = "";
435 DHandleEntryTxRx message;
436 message.deviceIdInfo.fromDeviceId[0] = 't';
437 EXPECT_EQ(dBinderRemoteListener.SendDataReply(deviceId, &message), false);
438 }
439
440 /**
441 * @tc.name: SendDataReply_003
442 * @tc.desc: Verify SendDataReply function when deviceId is valid and message has data.
443 * @tc.type: FUNC
444 */
445 HWTEST_F(DBinderRemoteListenerUnitTest, SendDataReply_003, TestSize.Level1)
446 {
447 DBinderRemoteListener dBinderRemoteListener;
448 const std::string deviceId = "12345";
449 DHandleEntryTxRx message;
450 message.deviceIdInfo.fromDeviceId[0] = 't';
451 EXPECT_EQ(dBinderRemoteListener.SendDataReply(deviceId, &message), false);
452 }
453
454 /**
455 * @tc.name: OpenSoftbusSession_001
456 * @tc.desc: Verify CreateClientSocket function with valid peerDeviceId.
457 * @tc.type: FUNC
458 */
459 HWTEST_F(DBinderRemoteListenerUnitTest, OpenSoftbusSession_001, TestSize.Level1)
460 {
461 DBinderRemoteListener dBinderRemoteListener;
462 const std::string peerDeviceId = "12345";
463 EXPECT_EQ(dBinderRemoteListener.CreateClientSocket(peerDeviceId), SOCKET_ID_INVALID);
464 }
465
466 /**
467 * @tc.name: OpenSoftbusSession_002
468 * @tc.desc: Verify CreateClientSocket function with null peerDeviceId.
469 * @tc.type: FUNC
470 */
471 HWTEST_F(DBinderRemoteListenerUnitTest, OpenSoftbusSession_002, TestSize.Level1)
472 {
473 DBinderRemoteListener dBinderRemoteListener;
474 const std::string peerDeviceId = "";
475 EXPECT_EQ(dBinderRemoteListener.CreateClientSocket(peerDeviceId), SOCKET_ID_INVALID);
476 }
477
478 /**
479 * @tc.name: GetPeerSocketId_001
480 * @tc.desc: Verify GetPeerSocketId function when networkId is valid.
481 * @tc.type: FUNC
482 */
483 HWTEST_F(DBinderRemoteListenerUnitTest, GetPeerSocketId_001, TestSize.Level1)
484 {
485 DBinderRemoteListener dBinderRemoteListener;
486 std::string networkId = NETWORKID_TEST;
487 int32_t socketId = 123;
488 dBinderRemoteListener.serverSocketInfos_[networkId] = socketId;
489 EXPECT_EQ(dBinderRemoteListener.GetPeerSocketId(networkId), socketId);
490 }
491
492 /**
493 * @tc.name: GetPeerSocketId_002
494 * @tc.desc: Verify GetPeerSocketId function when networkId is invalid.
495 * @tc.type: FUNC
496 */
497 HWTEST_F(DBinderRemoteListenerUnitTest, GetPeerSocketId_002, TestSize.Level1)
498 {
499 DBinderRemoteListener dBinderRemoteListener;
500 std::string networkId = "nonexistentNetworkId";
501 EXPECT_EQ(dBinderRemoteListener.GetPeerSocketId(networkId), SOCKET_ID_INVALID);
502 }
503
504 /**
505 * @tc.name: GetPeerSocketId_003
506 * @tc.desc: Verify GetPeerSocketId function when networkId is null.
507 * @tc.type: FUNC
508 */
509 HWTEST_F(DBinderRemoteListenerUnitTest, GetPeerSocketId_003, TestSize.Level1)
510 {
511 DBinderRemoteListener dBinderRemoteListener;
512 std::string networkId = "";
513 EXPECT_EQ(dBinderRemoteListener.GetPeerSocketId(networkId), SOCKET_ID_INVALID);
514 }
515
516 /**
517 * @tc.name: ClientOnBind_001
518 * @tc.desc: Verify ClientOnBind function.
519 * @tc.type: FUNC
520 */
521 HWTEST_F(DBinderRemoteListenerUnitTest, ClientOnBind_001, TestSize.Level1)
522 {
523 DBinderRemoteListener dBinderRemoteListener;
524 int32_t socketId = 1;
525 PeerSocketInfo info = {
526 .networkId = const_cast<char *>(NETWORKID_TEST.c_str()),
527 };
528
529 dBinderRemoteListener.ClientOnBind(socketId, info);
530 EXPECT_EQ(dBinderRemoteListener.listenSocketId_, SOCKET_ID_INVALID);
531 }
532
533 /**
534 * @tc.name: ClientOnBind_002
535 * @tc.desc: Verify ClientOnBind function.
536 * @tc.type: FUNC
537 */
538 HWTEST_F(DBinderRemoteListenerUnitTest, ClientOnBind_002, TestSize.Level1)
539 {
540 DBinderRemoteListener dBinderRemoteListener;
541 int32_t socketId = -1;
542 PeerSocketInfo info = {
543 .networkId = const_cast<char *>(NETWORKID_TEST.c_str()),
544 };
545
546 dBinderRemoteListener.ClientOnBind(socketId, info);
547 EXPECT_EQ(dBinderRemoteListener.listenSocketId_, SOCKET_ID_INVALID);
548 }
549
550 /**
551 * @tc.name: ClientOnBind_003
552 * @tc.desc: Verify ClientOnBind function.
553 * @tc.type: FUNC
554 */
555 HWTEST_F(DBinderRemoteListenerUnitTest, ClientOnBind_003, TestSize.Level1)
556 {
557 DBinderRemoteListener dBinderRemoteListener;
558 int32_t socketId = INT_MAX;
559 PeerSocketInfo info = {
560 .networkId = const_cast<char *>(NETWORKID_TEST.c_str()),
561 };
562
563 dBinderRemoteListener.ClientOnBind(socketId, info);
564 EXPECT_EQ(dBinderRemoteListener.listenSocketId_, SOCKET_ID_INVALID);
565 }
566
567 /**
568 * @tc.name: ClientOnShutdown_001
569 * @tc.desc: Verify ClientOnShutdown function when shutdown occurs for an existing socket.
570 * @tc.type: FUNC
571 */
572 HWTEST_F(DBinderRemoteListenerUnitTest, ClientOnShutdown_001, TestSize.Level1)
573 {
574 DBinderRemoteListener dBinderRemoteListener;
575 std::string networkId = "networkId";
576 int32_t socketId = 1;
577 dBinderRemoteListener.clientSocketInfos_[networkId] = socketId;
578 dBinderRemoteListener.ClientOnShutdown(socketId, SHUTDOWN_REASON_PEER);
579
580 EXPECT_EQ(dBinderRemoteListener.clientSocketInfos_.size(), 0);
581 }
582
583 /**
584 * @tc.name: ClientOnShutdown_002
585 * @tc.desc: Verify ClientOnShutdown function when shutdown occurs for a non-existing socket.
586 * @tc.type: FUNC
587 */
588 HWTEST_F(DBinderRemoteListenerUnitTest, ClientOnShutdown_002, TestSize.Level1)
589 {
590 DBinderRemoteListener dBinderRemoteListener;
591 std::string networkId = "networkId";
592 int32_t socketId = 1;
593 dBinderRemoteListener.clientSocketInfos_[networkId] = socketId;
594 dBinderRemoteListener.ClientOnShutdown(2, SHUTDOWN_REASON_PEER);
595
596 EXPECT_EQ(dBinderRemoteListener.clientSocketInfos_.size(), 1);
597 }
598
599 /**
600 * @tc.name: ClientOnShutdown_003
601 * @tc.desc: Verify ClientOnShutdown function with multiple entries.
602 * @tc.type: FUNC
603 */
604 HWTEST_F(DBinderRemoteListenerUnitTest, ClientOnShutdown_003, TestSize.Level1)
605 {
606 DBinderRemoteListener dBinderRemoteListener;
607 std::string networkId = "networkId";
608 std::string networkId1 = "networkId1";
609 int32_t socketId = 1;
610 int32_t socketId1 = 2;
611 dBinderRemoteListener.clientSocketInfos_[networkId] = socketId;
612 EXPECT_EQ(dBinderRemoteListener.clientSocketInfos_.size(), 1);
613
614 dBinderRemoteListener.clientSocketInfos_[networkId1] = socketId1;
615 EXPECT_EQ(dBinderRemoteListener.clientSocketInfos_.size(), 2);
616
617 dBinderRemoteListener.ClientOnShutdown(socketId, SHUTDOWN_REASON_PEER);
618 EXPECT_EQ(dBinderRemoteListener.clientSocketInfos_.size(), 1);
619 dBinderRemoteListener.ClientOnShutdown(socketId1, SHUTDOWN_REASON_PEER);
620 EXPECT_EQ(dBinderRemoteListener.clientSocketInfos_.size(), 0);
621 }
622