1 /*
2 * Copyright (c) 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 #include "channel_manager_test.h"
16 #include "channel_manager.h"
17 #include "dtbcollabmgr_log.h"
18 #include "securec.h"
19 #include "ichannel_listener_mock.h"
20 #include <chrono>
21 #include <thread>
22
23 namespace OHOS {
24 namespace DistributedCollab {
25 namespace {
26 static const std::string TAG = "DSchedCollabChannelManagerTest";
27 using namespace testing;
28 using namespace testing::ext;
29 static constexpr int32_t NUM_1234 = 1234;
30 static constexpr int32_t NUM_MINUS_1 = -1;
31 static constexpr int32_t MESSAGE_START_ID = 1001;
32 static constexpr int32_t BYTES_START_ID = 2001;
33 static constexpr int32_t STREAM_START_ID = 3001;
34 static constexpr int32_t CHANNGE_GAP = 1000;
35 static constexpr int32_t INVALID_CHANNEL = 9999;
36 static constexpr int32_t SLEEP_FOR_INIT = 2000;
37 static constexpr int32_t NUM_1024 = 1024;
38 static constexpr int32_t NUM_1 = 1;
39 static constexpr int32_t NUM_200 = 200;
40 constexpr int32_t MAX_LEN = 10 * 1024;
41 }
42
SetUpTestCase()43 void ChannelManagerTest::SetUpTestCase()
44 {
45 HILOGI("ChannelManagerTest::SetUpTestCase");
46 }
47
TearDownTestCase()48 void ChannelManagerTest::TearDownTestCase()
49 {
50 HILOGI("ChannelManagerTest::TearDownTestCase");
51 }
52
SetUp()53 void ChannelManagerTest::SetUp()
54 {
55 HILOGI("ChannelManagerTest::SetUp");
56 }
57
TearDown()58 void ChannelManagerTest::TearDown()
59 {
60 HILOGI("ChannelManagerTest::TearDown");
61 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_FOR_INIT));
62 ChannelManager::GetInstance().DeInit();
63 }
64
65 /**
66 * @tc.name: TestInit_Success
67 * @tc.desc: Test for Init when all conditions are successful
68 * @tc.type: FUNC
69 */
70 HWTEST_F(ChannelManagerTest, TestInit_Success, TestSize.Level1)
71 {
72 EXPECT_CALL(mockSoftbus, Socket(testing::_))
73 .WillOnce(testing::Return(NUM_1234));
74
75 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
76 .WillOnce(testing::Return(ERR_OK));
77
78 int32_t result = ChannelManager::GetInstance().Init(ownerName);
79
80 EXPECT_EQ(result, ERR_OK);
81 }
82
83 /**
84 * @tc.name: TestInit_SocketFailure
85 * @tc.desc: Test for Init when CreateServerSocket fails
86 * @tc.type: FUNC
87 */
88 HWTEST_F(ChannelManagerTest, TestInit_SocketFailure, TestSize.Level1)
89 {
90 EXPECT_CALL(mockSoftbus, Socket(testing::_))
91 .WillOnce(testing::Return(NUM_MINUS_1));
92
93 int32_t result = ChannelManager::GetInstance().Init(ownerName);
94
95 EXPECT_EQ(result, CREATE_SOCKET_FAILED);
96 }
97
98 /**
99 * @tc.name: TestInit_ListenFailure
100 * @tc.desc: Test for Init when Listen fails
101 * @tc.type: FUNC
102 */
103 HWTEST_F(ChannelManagerTest, TestInit_ListenFailure, TestSize.Level1)
104 {
105 EXPECT_CALL(mockSoftbus, Socket(testing::_))
106 .WillOnce(testing::Return(NUM_1234));
107
108 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
109 .WillOnce(testing::Return(-2));
110
111 int32_t result = ChannelManager::GetInstance().Init(ownerName);
112
113 EXPECT_EQ(result, LISTEN_SOCKET_FAILED);
114 }
115
116 /**
117 * @tc.name: CreateServerChannel_Success
118 * @tc.desc: Test for CreateServerChannel when the base channel is successfully created
119 * @tc.type: FUNC
120 */
121 HWTEST_F(ChannelManagerTest, CreateServerChannel_Success, TestSize.Level1)
122 {
123 std::string channelName = "TestChannel";
124 ChannelDataType dataType = ChannelDataType::MESSAGE;
125 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
126
127 int32_t channelId = ChannelManager::GetInstance().CreateServerChannel(channelName, dataType, peerInfo);
128 EXPECT_EQ(channelId, MESSAGE_START_ID);
129 }
130
131 /**
132 * @tc.name: CreateServerChannel_ExceedMax_Failed
133 * @tc.desc: Test for CreateServerChannel when the base channel is ExceedMax_Failed
134 * @tc.type: FUNC
135 */
136 HWTEST_F(ChannelManagerTest, CreateServerChannel_ExceedMax_Failed, TestSize.Level1)
137 {
138 std::string channelName = "TestChannel";
139 ChannelDataType dataType = ChannelDataType::MESSAGE;
140 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
141
142 int32_t channelId = 0;
143 for (int32_t i = 0; i < CHANNGE_GAP + 1; i++)
144 {
145 channelId = ChannelManager::GetInstance().CreateServerChannel(channelName, dataType, peerInfo);
146 }
147 EXPECT_EQ(channelId, CREATE_SERVER_CHANNEL_FAILED);
148 }
149
150 /**
151 * @tc.name: CreateClientChannel_Success
152 * @tc.desc: Test for CreateClientChannel when CreateBaseChannel and RegisterSocket succeed
153 * @tc.type: FUNC
154 */
155 HWTEST_F(ChannelManagerTest, CreateClientChannel_Success, TestSize.Level1)
156 {
157 // Setup the test data
158 std::string channelName = "testClientChannel";
159 ChannelDataType dataType = ChannelDataType::MESSAGE;
160 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
161
162 EXPECT_CALL(mockSoftbus, Socket(testing::_))
163 .WillOnce(testing::Return(NUM_1234));
164
165 // Call CreateClientChannel and check the result
166 int32_t result = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
167 EXPECT_EQ(result, MESSAGE_START_ID); // Should return valid channelId
168 }
169
170 /**
171 * @tc.name: CreateClientChannel_CreateSocket_Fail
172 * @tc.desc: Test for CreateClientChannel when CreateBaseChannel fails
173 * @tc.type: FUNC
174 */
175 HWTEST_F(ChannelManagerTest, CreateClientChannel_CreateSocket_Fail, TestSize.Level1)
176 {
177 // Setup the test data
178 std::string channelName = "testClientChannel";
179 ChannelDataType dataType = ChannelDataType::MESSAGE;
180 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
181
182 EXPECT_CALL(mockSoftbus, Socket(testing::_))
183 .WillOnce(testing::Return(NUM_MINUS_1));
184
185 // Call CreateClientChannel and check the result
186 int32_t result = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
187 EXPECT_EQ(result, CREATE_SOCKET_FAILED); // Should return valid channelId
188 }
189
190 /**
191 * @tc.name: CreateClientChannel_LoneName_Fail
192 * @tc.desc: Test for CreateClientChannel when RegisterSocket fails
193 * @tc.type: FUNC
194 */
195 HWTEST_F(ChannelManagerTest, CreateClientChannel_LoneName_Fail, TestSize.Level1)
196 {
197 // Setup the test data
198 std::string channelName = "ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss";
199 ChannelDataType dataType = ChannelDataType::MESSAGE;
200 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
201
202 // Call CreateClientChannel and check the result
203 int32_t result = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
204 EXPECT_EQ(result, CREATE_SOCKET_FAILED); // Should return valid channelId
205 }
206
207 /**
208 * @tc.name: CreateClientChannel_ExceedNum_Fail
209 * @tc.desc: Test for CreateClientChannel when RegisterSocket fails
210 * @tc.type: FUNC
211 */
212 HWTEST_F(ChannelManagerTest, CreateClientChannel_ExceedNum_Fail, TestSize.Level1)
213 {
214 // Setup the test data
215 std::string channelName = "testClientChannel";
216 ChannelDataType dataType = ChannelDataType::MESSAGE;
217 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
218
219 int32_t channelId = 0;
220 for (int32_t i = 0; i < CHANNGE_GAP + 1; i++)
221 {
222 channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
223 }
224 EXPECT_EQ(channelId, CREATE_CLIENT_CHANNEL_FAILED);
225 }
226
227 /**
228 * @tc.name: DeleteChannel_Success
229 * @tc.desc: Test for DeleteChannel when valid channelId is provided and socket resources are cleared successfully
230 * @tc.type: FUNC
231 */
232 HWTEST_F(ChannelManagerTest, DeleteChannel_Success, TestSize.Level1)
233 {
234 // Setup the test data
235 std::string channelName = "testDeleteChannel";
236 ChannelDataType dataType = ChannelDataType::MESSAGE;
237 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
238
239 EXPECT_CALL(mockSoftbus, Socket(testing::_))
240 .WillOnce(testing::Return(NUM_1234));
241
242 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
243 ASSERT_EQ(channelId, MESSAGE_START_ID); // Ensure the channel is created successfully
244
245 int32_t deleteResult = ChannelManager::GetInstance().DeleteChannel(channelId);
246 EXPECT_EQ(deleteResult, channelId);
247 }
248
249 /**
250 * @tc.name: DeleteChannel_InvalidChannelId
251 * @tc.desc: Test for DeleteChannel when invalid channelId is provided
252 * @tc.type: FUNC
253 */
254 HWTEST_F(ChannelManagerTest, DeleteChannel_InvalidChannelId, TestSize.Level1)
255 {
256 int32_t invalidChannelId = -1;
257 int32_t result = ChannelManager::GetInstance().DeleteChannel(invalidChannelId);
258 EXPECT_EQ(result, INVALID_CHANNEL_ID);
259 }
260
261 /**
262 * @tc.name: RegisterChannelListener_NullListener
263 * @tc.desc: Test for RegisterChannelListener when listener is nullptr
264 * @tc.type: FUNC
265 */
266 HWTEST_F(ChannelManagerTest, RegisterChannelListener_NullListener, TestSize.Level1)
267 {
268 int32_t channelId = MESSAGE_START_ID;
269 std::shared_ptr<IChannelListener> nullListener = nullptr;
270 int32_t result = ChannelManager::GetInstance().RegisterChannelListener(channelId, nullListener);
271 EXPECT_EQ(result, INVALID_LISTENER);
272 }
273
274 /**
275 * @tc.name: RegisterChannelListener_ChannelIdNotExist
276 * @tc.desc: Test for RegisterChannelListener when channelId is not present in listenersMap_
277 * @tc.type: FUNC
278 */
279 HWTEST_F(ChannelManagerTest, RegisterChannelListener_ChannelIdNotExist, TestSize.Level1)
280 {
281 int32_t channelId = MESSAGE_START_ID;
282 std::shared_ptr<IChannelListener> listener = std::make_shared<MockChannelListener>();
283 int32_t result = ChannelManager::GetInstance().RegisterChannelListener(channelId, listener);
284 EXPECT_EQ(result, ERR_OK);
285 }
286
287 /**
288 * @tc.name: RegisterChannelListener_ListenerExist
289 * @tc.desc: Test for RegisterChannelListener when Listener already has listeners
290 * @tc.type: FUNC
291 */
292 HWTEST_F(ChannelManagerTest, RegisterChannelListener_ListenerExist, TestSize.Level1)
293 {
294 int32_t channelId = MESSAGE_START_ID;
295 std::shared_ptr<IChannelListener> listener = std::make_shared<MockChannelListener>();
296 ChannelManager::GetInstance().RegisterChannelListener(channelId, listener);
297 int32_t result = ChannelManager::GetInstance().RegisterChannelListener(channelId, listener);
298 EXPECT_EQ(result, ERR_OK);
299 }
300
301 /**
302 * @tc.name: ConnectChannel_Success
303 * @tc.desc: Test for ConnectChannel when valid channelId and client sockets are present
304 * @tc.type: FUNC
305 */
306 HWTEST_F(ChannelManagerTest, ConnectChannel_Success, TestSize.Level1)
307 {
308 // Init
309 EXPECT_CALL(mockSoftbus, Socket(testing::_))
310 .WillRepeatedly(testing::Return(NUM_1234));
311 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
312 .WillOnce(testing::Return(ERR_OK));
313 int32_t result = ChannelManager::GetInstance().Init(ownerName);
314 EXPECT_EQ(result, ERR_OK);
315
316 // CreateClient
317 // Setup the test data
318 std::string channelName = "testClientChannel";
319 ChannelDataType dataType = ChannelDataType::MESSAGE;
320 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
321
322 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
323 EXPECT_EQ(channelId, MESSAGE_START_ID); // Should return valid channelId
324
325 // Step 3: Mock Bind to succeed
326 EXPECT_CALL(mockSoftbus, Bind(testing::_, testing::_, testing::_, testing::_))
327 .WillOnce(testing::Return(ERR_OK)); // Mock Bind to succeed
328
329 // Call ConnectChannel and check the result
330 result = ChannelManager::GetInstance().ConnectChannel(channelId);
331 EXPECT_EQ(result, ERR_OK);
332 }
333
334 /**
335 * @tc.name: ConnectChannel_BindFailed
336 * @tc.desc: Test for ConnectChannel when Bind fails.
337 * @tc.type: FUNC
338 */
339 HWTEST_F(ChannelManagerTest, ConnectChannel_BindFailed, TestSize.Level1)
340 {
341 // Init
342 EXPECT_CALL(mockSoftbus, Socket(testing::_))
343 .WillRepeatedly(testing::Return(NUM_1234));
344 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
345 .WillOnce(testing::Return(ERR_OK));
346 int32_t result = ChannelManager::GetInstance().Init(ownerName);
347 EXPECT_EQ(result, ERR_OK);
348
349 // CreateClient
350 // Setup the test data
351 std::string channelName = "testClientChannel";
352 ChannelDataType dataType = ChannelDataType::MESSAGE;
353 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
354
355 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
356 EXPECT_EQ(channelId, MESSAGE_START_ID); // Should return valid channelId
357
358 // Step 3: Mock Bind to succeed
359 EXPECT_CALL(mockSoftbus, Bind(testing::_, testing::_, testing::_, testing::_))
360 .WillOnce(testing::Return(NUM_MINUS_1)); // Mock Bind to succeed
361
362 // Call ConnectChannel and check the result
363 result = ChannelManager::GetInstance().ConnectChannel(channelId);
364 EXPECT_EQ(result, CONNECT_CHANNEL_FAILED);
365 }
366
367 /**
368 * @tc.name: ConnectChannel_InvalidChannelId
369 * @tc.desc: Test for ConnectChannel when channelId is invalid (not found in channelInfoMap_).
370 * @tc.type: FUNC
371 */
372 HWTEST_F(ChannelManagerTest, ConnectChannel_InvalidChannelId, TestSize.Level1)
373 {
374 // Simulate channelId not being in the channelInfoMap_
375 int32_t invalidChannelId = INVALID_CHANNEL; // Invalid channel ID
376 int32_t connectResult = ChannelManager::GetInstance().ConnectChannel(invalidChannelId);
377
378 // Verify that ConnectChannel returns INVALID_CHANNEL_ID for an invalid channelId
379 EXPECT_EQ(connectResult, INVALID_CHANNEL_ID);
380 }
381
382 /**
383 * @tc.name: ConnectChannel_RepeatConnection
384 * @tc.desc: Test for ConnectChannel when the channelId is already connected.
385 * @tc.type: FUNC
386 */
387 HWTEST_F(ChannelManagerTest, ConnectChannel_RepeatConnection, TestSize.Level1)
388 {
389 // Step 1: Initialize the ChannelManager
390 EXPECT_CALL(mockSoftbus, Socket(testing::_))
391 .WillRepeatedly(testing::Return(NUM_1234));
392 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
393 .WillOnce(testing::Return(ERR_OK)); // Mock Listen to return success
394
395 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
396 EXPECT_EQ(initResult, ERR_OK); // Ensure Init was successful
397
398 // Step 2: Create Client Channel
399 std::string channelName = "testClientChannel";
400 ChannelDataType dataType = ChannelDataType::MESSAGE;
401 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
402
403 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
404 EXPECT_EQ(channelId, MESSAGE_START_ID); // Verify the channel ID is correctly returned
405
406 // Step 3: Mock Bind to succeed
407 EXPECT_CALL(mockSoftbus, Bind(testing::_, testing::_, testing::_, testing::_))
408 .WillOnce(testing::Return(ERR_OK)); // Mock Bind to succeed
409
410 // Call ConnectChannel and check the result
411 int32_t result = ChannelManager::GetInstance().ConnectChannel(channelId);
412 EXPECT_EQ(result, ERR_OK);
413
414 // Step 4: Test ConnectChannel with already connected channelId
415 // When channelId is already connected, ConnectChannel should return ERR_OK
416 int32_t connectResult = ChannelManager::GetInstance().ConnectChannel(channelId);
417 EXPECT_EQ(connectResult, ERR_OK); // Already connected, no need to connect again
418 }
419
420 /**
421 * @tc.name: OnSocketConnected_Success_WithCallback
422 * @tc.desc: Test for OnSocketConnected when the socket is successfully connected and valid channel is found,
423 * and callback methods are invoked correctly.
424 * @tc.type: FUNC
425 */
426 HWTEST_F(ChannelManagerTest, OnSocketConnected_Success_WithCallback, TestSize.Level1)
427 {
428 // Step 1: Initialize the ChannelManager
429 EXPECT_CALL(mockSoftbus, Socket(testing::_))
430 .WillRepeatedly(testing::Return(NUM_1234));
431 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
432 .WillOnce(testing::Return(ERR_OK)); // Mock Listen to return success
433
434 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
435 EXPECT_EQ(initResult, ERR_OK); // Ensure Init was successful
436
437 std::string channelName = "TestChannel";
438 ChannelDataType dataType = ChannelDataType::MESSAGE;
439 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
440 int32_t channelId = ChannelManager::GetInstance().CreateServerChannel(channelName, dataType, peerInfo);
441 EXPECT_EQ(channelId, MESSAGE_START_ID); // Assuming MESSAGE_START_ID is defined
442
443 // Step 2: Prepare PeerSocketInfo with correctly formatted name
444 std::string prefix = "ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss";
445 std::string name = prefix + "_M_" + channelName;
446 PeerSocketInfo info = {
447 .name = const_cast<char*>(name.c_str()), // valid name
448 .networkId = nullptr, // network ID
449 .pkgName = nullptr, // package name
450 .dataType = DATA_TYPE_MESSAGE // channel data type
451 };
452
453 int32_t socketId = NUM_1234; // valid socketId
454
455 // Mock the listener and expect the OnConnect callback to be triggered
456 auto mockListener = std::make_shared<MockChannelListener>();
457 EXPECT_CALL(*mockListener, OnConnect(channelId)).Times(1);
458
459 // Register listener for the channelId
460 int32_t result = ChannelManager::GetInstance().RegisterChannelListener(channelId, mockListener);
461 EXPECT_EQ(result, ERR_OK);
462
463 // Call OnSocketConnected, which should trigger the OnConnect callback
464 ChannelManager::GetInstance().OnSocketConnected(socketId, info);
465 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_FOR_INIT));
466 }
467
468 /**
469 * @tc.name: OnSocketConnected_InvalidChannelNameFormat_WithCallback
470 * @tc.desc: Test for OnSocketConnected when the channel name Format is invalid and cannot be parsed,
471 * and the OnError callback is triggered.
472 * @tc.type: FUNC
473 */
474 HWTEST_F(ChannelManagerTest, OnSocketConnected_InvalidChannelNameFormat_WithCallback, TestSize.Level1)
475 {
476 // Step 1: Create Server Channel
477 std::string channelName = "TestChannel";
478 ChannelDataType dataType = ChannelDataType::MESSAGE;
479 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
480 int32_t channelId = ChannelManager::GetInstance().CreateServerChannel(channelName, dataType, peerInfo);
481 EXPECT_EQ(channelId, MESSAGE_START_ID); // Assuming MESSAGE_START_ID is defined
482
483 // Step 2: Prepare PeerSocketInfo with invalid name
484 std::string name = "ohos.distributedschedule.dms.InvalidChannelName";
485 PeerSocketInfo info = {
486 .name = const_cast<char*>(name.c_str()), // invalid name
487 .networkId = nullptr, // network ID
488 .pkgName = nullptr, // package name
489 .dataType = DATA_TYPE_MESSAGE // channel data type
490 };
491
492 int32_t socketId = NUM_1234; // valid socketId
493
494 // Mock the listener and expect
495 auto mockListener = std::make_shared<MockChannelListener>();
496 EXPECT_CALL(*mockListener, OnConnect(channelId)).Times(0);
497
498 // Register listener for the channelId
499 int32_t result = ChannelManager::GetInstance().RegisterChannelListener(channelId, mockListener);
500 EXPECT_EQ(result, ERR_OK);
501
502 // Call OnSocketConnected, which should trigger the OnError callback due to invalid channel name
503 ChannelManager::GetInstance().OnSocketConnected(socketId, info);
504 }
505
506 /**
507 * @tc.name: OnSocketConnected_InvalidChannelType_WithCallback
508 * @tc.desc: Test for OnSocketConnected when the channelId Type invalid, and the OnError callback is triggered.
509 * @tc.type: FUNC
510 */
511 HWTEST_F(ChannelManagerTest, OnSocketConnected_InvalidChannelType_WithCallback, TestSize.Level1)
512 {
513 // Step 1: Create Server Channel
514 std::string channelName = "TestChannel";
515 ChannelDataType dataType = ChannelDataType::MESSAGE;
516 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
517 int32_t channelId = ChannelManager::GetInstance().CreateServerChannel(channelName, dataType, peerInfo);
518 EXPECT_EQ(channelId, MESSAGE_START_ID); // Assuming MESSAGE_START_ID is defined
519
520 // Step 2: Prepare PeerSocketInfo with valid name but invalid channelId
521 std::string prefix = "ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss";
522 std::string name = prefix + "_IVA_" + channelName;
523 PeerSocketInfo info = {
524 .name = const_cast<char*>(name.c_str()), // invalid type
525 .networkId = nullptr, // network ID
526 .pkgName = nullptr, // package name
527 .dataType = DATA_TYPE_MESSAGE // channel data type
528 };
529
530 int32_t socketId = NUM_1234; // valid socketId
531
532 // Mock the listener and expect the OnError callback to be triggered
533 auto mockListener = std::make_shared<MockChannelListener>();
534 EXPECT_CALL(*mockListener, OnConnect(channelId)).Times(0);
535
536 // Register listener for the channelId
537 int32_t result = ChannelManager::GetInstance().RegisterChannelListener(channelId, mockListener);
538 EXPECT_EQ(result, ERR_OK);
539
540 // Call OnSocketConnected, which should trigger the OnError callback due to invalid channelId
541 ChannelManager::GetInstance().OnSocketConnected(socketId, info);
542 }
543
544 /**
545 * @tc.name: OnSocketConnected_InvalidChannelName_WithCallback
546 * @tc.desc: Test for OnSocketConnected when registering the socket fails,
547 * and verify if the OnError callback is triggered.
548 * @tc.type: FUNC
549 */
550 HWTEST_F(ChannelManagerTest, OnSocketConnected_InvalidChannelName_WithCallback, TestSize.Level1)
551 {
552 // Step 1: Create Server Channel
553 std::string channelName = "TestChannel";
554 ChannelDataType dataType = ChannelDataType::MESSAGE;
555 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
556 int32_t channelId = ChannelManager::GetInstance().CreateServerChannel(channelName, dataType, peerInfo);
557 EXPECT_EQ(channelId, MESSAGE_START_ID); // Assuming MESSAGE_START_ID is defined
558
559 // Step 2: Prepare PeerSocketInfo with correct name
560 std::string prefix = "ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss";
561 std::string name = prefix + "_M_" + channelName + "invalid";
562 PeerSocketInfo info = {
563 .name = const_cast<char*>(name.c_str()), // invalid name
564 .networkId = nullptr, // network ID
565 .pkgName = nullptr, // package name
566 .dataType = DATA_TYPE_MESSAGE // channel data type
567 };
568
569 int32_t socketId = NUM_1234; // valid socketId
570
571 // Mock the listener and expect the OnError callback to be triggered
572 auto mockListener = std::make_shared<MockChannelListener>();
573 EXPECT_CALL(*mockListener, OnConnect(channelId)).Times(0);
574
575 // Register listener for the channelId
576 int32_t result = ChannelManager::GetInstance().RegisterChannelListener(channelId, mockListener);
577 EXPECT_EQ(result, ERR_OK);
578
579 ChannelManager::GetInstance().OnSocketConnected(socketId, info);
580 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().OnSocketConnected(-1, info));
581 }
582
583 /**
584 * @tc.name: OnSocketClosed_CallbackInvokedAndChannelDeleted
585 * @tc.desc: Test for OnSocketClosed when the socket is closed and callback is invoked, and channel is deleted.
586 * @tc.type: FUNC
587 */
588 HWTEST_F(ChannelManagerTest, OnSocketClosed_CallbackInvokedAndChannelDeleted, TestSize.Level1)
589 {
590 // Step 1: Initialize the ChannelManager
591 EXPECT_CALL(mockSoftbus, Socket(testing::_))
592 .WillRepeatedly(testing::Return(NUM_1234));
593 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
594 .WillOnce(testing::Return(ERR_OK)); // Mock Listen to return success
595
596 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
597 EXPECT_EQ(initResult, ERR_OK); // Ensure Init was successful
598
599 // CreateClient
600 // Setup the test data
601 std::string channelName = "testClientChannel";
602 ChannelDataType dataType = ChannelDataType::MESSAGE;
603 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
604 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
605 EXPECT_EQ(channelId, MESSAGE_START_ID); // Should return valid channelId
606
607 auto mockListener = std::make_shared<MockChannelListener>();
608 int32_t result = ChannelManager::GetInstance().RegisterChannelListener(channelId, mockListener);
609 EXPECT_EQ(result, ERR_OK);
610
611 // Step 3: Mock Bind to succeed
612 EXPECT_CALL(mockSoftbus, Bind(testing::_, testing::_, testing::_, testing::_))
613 .WillOnce(testing::Return(ERR_OK)); // Mock Bind to succeed
614
615 // Call ConnectChannel and check the result
616 result = ChannelManager::GetInstance().ConnectChannel(channelId);
617 EXPECT_EQ(result, ERR_OK);
618
619 ChannelManager::GetInstance().OnSocketClosed(NUM_1234, ShutdownReason::SHUTDOWN_REASON_LNN_OFFLINE);
620 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_FOR_INIT));
621 }
622
623 /**
624 * @tc.name: OnSocketClosed_WhenNoChannelID
625 * @tc.desc: Test for OnSocketClosed when the socket is WhenNoChannelID.
626 * @tc.type: FUNC
627 */
628 HWTEST_F(ChannelManagerTest, OnSocketClosed_WhenNoChannelID, TestSize.Level1)
629 {
630 EXPECT_CALL(mockSoftbus, Socket(testing::_))
631 .WillRepeatedly(testing::Return(NUM_1234));
632 // CreateClient
633 // Setup the test data
634 std::string channelName = "testClientChannel";
635 ChannelDataType dataType = ChannelDataType::MESSAGE;
636 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
637 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
638 EXPECT_EQ(channelId, MESSAGE_START_ID); // Should return valid channelId
639
640 auto mockListener = std::make_shared<MockChannelListener>();
641 int32_t result = ChannelManager::GetInstance().RegisterChannelListener(channelId, mockListener);
642 EXPECT_EQ(result, ERR_OK);
643 EXPECT_CALL(*mockListener, OnDisConnect(channelId, ShutdownReason::SHUTDOWN_REASON_LNN_OFFLINE)).Times(0);
644
645 ChannelManager::GetInstance().OnSocketClosed(INVALID_CHANNEL_ID, ShutdownReason::SHUTDOWN_REASON_LNN_OFFLINE);
646 }
647
648 /**
649 * @tc.name: OnSocketClosed_InvalidSocketIdWithChannelId
650 * @tc.desc: Test for OnSocketClosed when the socket is InvalidSocketIdWithChannelId.
651 * @tc.type: FUNC
652 */
653 HWTEST_F(ChannelManagerTest, OnSocketClosed_InvalidSocketIdWithChannelId, TestSize.Level1)
654 {
655 // Step 1: Initialize the ChannelManager
656 EXPECT_CALL(mockSoftbus, Socket(testing::_))
657 .WillRepeatedly(testing::Return(NUM_1234));
658 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
659 .WillOnce(testing::Return(ERR_OK)); // Mock Listen to return success
660
661 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
662 EXPECT_EQ(initResult, ERR_OK); // Ensure Init was successful
663
664 // CreateClient
665 // Setup the test data
666 std::string channelName = "testClientChannel";
667 ChannelDataType dataType = ChannelDataType::MESSAGE;
668 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
669 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
670 EXPECT_EQ(channelId, MESSAGE_START_ID); // Should return valid channelId
671
672 auto mockListener = std::make_shared<MockChannelListener>();
673 int32_t result = ChannelManager::GetInstance().RegisterChannelListener(channelId, mockListener);
674 EXPECT_EQ(result, ERR_OK);
675 EXPECT_CALL(*mockListener, OnDisConnect(channelId, ShutdownReason::SHUTDOWN_REASON_LNN_OFFLINE)).Times(0);
676
677 ChannelManager::GetInstance().OnSocketClosed(INVALID_CHANNEL_ID, ShutdownReason::SHUTDOWN_REASON_LNN_OFFLINE);
678 }
679
680 /**
681 * @tc.name: SendBytes_Success
682 * @tc.desc: Test for SendBytes when both channel and connection are successfully established.
683 * @tc.type: FUNC
684 */
685 HWTEST_F(ChannelManagerTest, SendBytes_Success, TestSize.Level1)
686 {
687 // Step 1: Initialize the ChannelManager
688 EXPECT_CALL(mockSoftbus, Socket(testing::_))
689 .WillRepeatedly(testing::Return(NUM_1234)); // Mock Socket to return a valid socket ID
690 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
691 .WillOnce(testing::Return(ERR_OK)); // Mock Listen to return success
692
693 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
694 EXPECT_EQ(initResult, ERR_OK); // Ensure Init was successful
695
696 // Step 2: Create Client Channel
697 std::string channelName = "TestChannel";
698 ChannelDataType dataType = ChannelDataType::MESSAGE; // Use TransDataType for the data type
699 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
700
701 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
702 EXPECT_EQ(channelId, MESSAGE_START_ID); // Verify the channel ID is correctly returned
703
704 // Step 3: Mock Bind to succeed
705 EXPECT_CALL(mockSoftbus, Bind(testing::_, testing::_, testing::_, testing::_))
706 .WillOnce(testing::Return(ERR_OK)); // Mock Bind to succeed
707
708 // Step 4: Call ConnectChannel to establish the connection
709 int32_t result = ChannelManager::GetInstance().ConnectChannel(channelId);
710 EXPECT_EQ(result, ERR_OK); // Verify the connection was established
711
712 // Step 5: Prepare data to send
713 std::shared_ptr<AVTransDataBuffer> dataBuffer = std::make_shared<AVTransDataBuffer>(NUM_1234);
714 EXPECT_CALL(mockSoftbus, GetSessionOption(NUM_1234, testing::_, testing::_, sizeof(uint32_t)))
715 .WillOnce(testing::Invoke([&](int sessionId, SessionOption option,
__anonc2847fdb0202(int sessionId, SessionOption option, void* optionValue, uint32_t valueSize) 716 void* optionValue, uint32_t valueSize) {
717 *reinterpret_cast<uint32_t*>(optionValue) = 4 * 1024 * 1024;
718 return ERR_OK;
719 }));
720
721 EXPECT_CALL(mockSoftbus, SendBytes(NUM_1234, testing::_, dataBuffer->Size() + SessionDataHeader::HEADER_LEN))
722 .WillOnce(testing::Return(ERR_OK));
723
724 // Step 6: Send the data
725 result = ChannelManager::GetInstance().SendBytes(channelId, dataBuffer);
726 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_FOR_INIT));
727 // Validate the result of SendBytes - it should return ERR_OK as everything is valid
728 EXPECT_EQ(result, ERR_OK);
729 }
730
731 /**
732 * @tc.name: SendBytes_InvalidChannelId
733 * @tc.desc: Test for SendBytes when channelId is invalid.
734 * @tc.type: FUNC
735 */
736 HWTEST_F(ChannelManagerTest, SendBytes_InvalidChannelId, TestSize.Level1)
737 {
738 // Prepare an invalid channelId
739 int32_t invalidChannelId = INVALID_CHANNEL; // Invalid channelId
740 std::shared_ptr<AVTransDataBuffer> dataBuffer = std::make_shared<AVTransDataBuffer>(NUM_1234);
741
742 // Step 1: Call SendBytes with invalid channelId
743 int32_t result = ChannelManager::GetInstance().SendBytes(invalidChannelId, dataBuffer);
744
745 // Validate result - should return INVALID_CHANNEL_ID
746 EXPECT_EQ(result, INVALID_CHANNEL_ID);
747 }
748
749 /**
750 * @tc.name: SendBytes_NullData
751 * @tc.desc: Test for SendBytes when data is nullptr.
752 * @tc.type: FUNC
753 */
754 HWTEST_F(ChannelManagerTest, SendBytes_NullData, TestSize.Level1)
755 {
756 std::shared_ptr<AVTransDataBuffer> nullData = nullptr;
757 int32_t result = ChannelManager::GetInstance().SendBytes(MESSAGE_START_ID, nullData);
758
759 // Validate the result - should return INVALID_CHANNEL_ID as data is null
760 EXPECT_EQ(result, INVALID_CHANNEL_ID);
761 }
762
763 /**
764 * @tc.name: SendBytes_NotConnect
765 * @tc.desc: Test for SendBytes when NotConnect.
766 * @tc.type: FUNC
767 */
768 HWTEST_F(ChannelManagerTest, SendBytes_NotConnect, TestSize.Level1)
769 {
770 // Step 1: Initialize the ChannelManager
771 EXPECT_CALL(mockSoftbus, Socket(testing::_))
772 .WillRepeatedly(testing::Return(NUM_1234)); // Mock Socket to return a valid socket ID
773 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
774 .WillOnce(testing::Return(ERR_OK)); // Mock Listen to return success
775
776 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
777 EXPECT_EQ(initResult, ERR_OK); // Ensure Init was successful
778
779 // Step 2: Create Client Channel
780 std::string channelName = "TestChannel";
781 ChannelDataType dataType = ChannelDataType::MESSAGE;
782 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
783
784 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
785 EXPECT_EQ(channelId, MESSAGE_START_ID); // Verify the channel ID is correctly returned
786
787 // Step 3: Mock Bind to succeed
788 EXPECT_CALL(mockSoftbus, Bind(testing::_, testing::_, testing::_, testing::_))
789 .WillOnce(testing::Return(-1)); // Mock Bind to succeed
790
791 // Step 4: Call ConnectChannel to establish the connection
792 int32_t result = ChannelManager::GetInstance().ConnectChannel(channelId);
793 EXPECT_EQ(result, CONNECT_CHANNEL_FAILED); // Verify the connection was established
794
795 std::shared_ptr<AVTransDataBuffer> dataBuffer = std::make_shared<AVTransDataBuffer>(NUM_1234);
796
797 result = ChannelManager::GetInstance().SendBytes(channelId, dataBuffer);
798 }
799
800 /**
801 * @tc.name: SendStream_Success
802 * @tc.desc: Test for SendStream when both channel and connection are successfully established.
803 * @tc.type: FUNC
804 */
805 HWTEST_F(ChannelManagerTest, SendStream_Success, TestSize.Level1)
806 {
807 // Step 1: Initialize the ChannelManager
808 EXPECT_CALL(mockSoftbus, Socket(testing::_))
809 .WillRepeatedly(testing::Return(NUM_1234)); // Mock Socket to return a valid socket ID
810 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
811 .WillOnce(testing::Return(ERR_OK)); // Mock Listen to return success
812
813 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
814 EXPECT_EQ(initResult, ERR_OK); // Ensure Init was successful
815
816 // Step 2: Create Client Channel
817 std::string channelName = "TestStreamChannel";
818 ChannelDataType dataType = ChannelDataType::MESSAGE; // Using raw stream type for the data
819 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
820
821 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
822 EXPECT_EQ(channelId, MESSAGE_START_ID); // Verify the channel ID is correctly returned
823
824 // Step 3: Mock Bind to succeed
825 EXPECT_CALL(mockSoftbus, Bind(testing::_, testing::_, testing::_, testing::_))
826 .WillOnce(testing::Return(ERR_OK)); // Mock Bind to succeed
827
828 // Step 4: Call ConnectChannel to establish the connection
829 int32_t result = ChannelManager::GetInstance().ConnectChannel(channelId);
830 EXPECT_EQ(result, ERR_OK); // Verify the connection was established
831
832 // Step 5: Prepare data for stream
833 std::shared_ptr<AVTransDataBuffer> dataBuffer = std::make_shared<AVTransDataBuffer>(NUM_1024);
834
835 AVTransStreamDataExt extData;
836 extData.flag_ = AvCodecBufferFlag::AVCODEC_BUFFER_FLAG_CODEC_DATA;
837 extData.index_ = NUM_1;
838 extData.pts_ = NUM_200;
839 extData.startEncodeT_ = NUM_200;
840 extData.finishEncodeT_ = NUM_200;
841 extData.sendEncodeT_ = NUM_200;
842
843 std::shared_ptr<AVTransStreamData> streamData = std::make_shared<AVTransStreamData>(dataBuffer, extData);
844
845 // Step 6: Call SendStream
846 EXPECT_CALL(mockSoftbus, SendStream(NUM_1234, testing::_, testing::_, testing::_))
847 .WillRepeatedly(testing::Return(ERR_OK));
848 result = ChannelManager::GetInstance().SendStream(channelId, streamData);
849 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_FOR_INIT));
850 // Validate the result - it should return ERR_OK as everything is valid
851 EXPECT_EQ(result, ERR_OK);
852 }
853
854 /**
855 * @tc.name: SendStream_InvalidChannelId
856 * @tc.desc: Test for SendStream when channelId is invalid.
857 * @tc.type: FUNC
858 */
859 HWTEST_F(ChannelManagerTest, SendStream_InvalidChannelId, TestSize.Level1)
860 {
861 // Prepare an invalid channelId
862 int32_t invalidChannelId = -1; // Invalid channelId
863 std::shared_ptr<AVTransDataBuffer> dataBuffer = std::make_shared<AVTransDataBuffer>(NUM_1024);
864
865 AVTransStreamDataExt extData;
866 extData.flag_ = AvCodecBufferFlag::AVCODEC_BUFFER_FLAG_CODEC_DATA;
867 extData.index_ = NUM_1;
868 extData.pts_ = NUM_200;
869 extData.startEncodeT_ = NUM_200;
870 extData.finishEncodeT_ = NUM_200;
871 extData.sendEncodeT_ = NUM_200;
872
873 std::shared_ptr<AVTransStreamData> streamData = std::make_shared<AVTransStreamData>(dataBuffer, extData);
874
875 // Step 1: Call SendStream with invalid channelId
876 int32_t result = ChannelManager::GetInstance().SendStream(invalidChannelId, streamData);
877
878 // Validate result - should return INVALID_CHANNEL_ID
879 EXPECT_EQ(result, INVALID_CHANNEL_ID);
880 }
881
882 /**
883 * @tc.name: SendStream_NullData
884 * @tc.desc: Test for SendStream when data is nullptr.
885 * @tc.type: FUNC
886 */
887 HWTEST_F(ChannelManagerTest, SendStream_NullData, TestSize.Level1)
888 {
889 // Prepare valid channelId
890 int32_t validChannelId = MESSAGE_START_ID; // Valid channelId
891 std::shared_ptr<AVTransDataBuffer> dataBuffer = nullptr; // Set data to nullptr
892
893 // Step 1: Call SendStream with nullptr data
894 int32_t result = ChannelManager::GetInstance().SendStream(validChannelId, nullptr);
895
896 // Validate result - should return INVALID_CHANNEL_ID as data is null
897 EXPECT_EQ(result, INVALID_CHANNEL_ID);
898 }
899
900 /**
901 * @tc.name: SendStream_NotConnect
902 * @tc.desc: Test for SendStream when NotConnect.
903 * @tc.type: FUNC
904 */
905 HWTEST_F(ChannelManagerTest, SendStream_NotConnect, TestSize.Level1)
906 {
907 // Step 1: Initialize the ChannelManager
908 EXPECT_CALL(mockSoftbus, Socket(testing::_))
909 .WillRepeatedly(testing::Return(NUM_1234)); // Mock Socket to return a valid socket ID
910 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
911 .WillOnce(testing::Return(ERR_OK)); // Mock Listen to return success
912
913 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
914 EXPECT_EQ(initResult, ERR_OK); // Ensure Init was successful
915
916 // Step 2: Create Client Channel
917 std::string channelName = "TestStreamChannel";
918 ChannelDataType dataType = ChannelDataType::MESSAGE; // Using raw stream type for the data
919 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
920
921 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
922 EXPECT_EQ(channelId, MESSAGE_START_ID); // Verify the channel ID is correctly returned
923
924 // Step 3: Mock Bind to succeed
925 EXPECT_CALL(mockSoftbus, Bind(testing::_, testing::_, testing::_, testing::_))
926 .WillOnce(testing::Return(-1)); // Mock Bind to succeed
927
928 // Step 4: Call ConnectChannel to establish the connection
929 int32_t result = ChannelManager::GetInstance().ConnectChannel(channelId);
930 EXPECT_EQ(result, CONNECT_CHANNEL_FAILED); // Verify the connection was established
931
932
933 // Step 6: Prepare data for stream
934 std::shared_ptr<AVTransDataBuffer> dataBuffer = std::make_shared<AVTransDataBuffer>(NUM_1024);
935
936 AVTransStreamDataExt extData;
937 extData.flag_ = AvCodecBufferFlag::AVCODEC_BUFFER_FLAG_CODEC_DATA;
938 extData.index_ = NUM_1;
939 extData.pts_ = NUM_200;
940 extData.startEncodeT_ = NUM_200;
941 extData.finishEncodeT_ = NUM_200;
942 extData.sendEncodeT_ = NUM_200;
943
944 std::shared_ptr<AVTransStreamData> streamData = std::make_shared<AVTransStreamData>(dataBuffer, extData);
945
946 // Step 7: Call SendStream
947 result = ChannelManager::GetInstance().SendStream(channelId, streamData);
948 }
949
950 /**
951 * @tc.name: SendMessage_Success
952 * @tc.desc: Test for SendMessage when channelId is valid and PostTask succeeds.
953 * @tc.type: FUNC
954 */
955 HWTEST_F(ChannelManagerTest, SendMessage_Success, TestSize.Level1)
956 {
957 // Step 1: Initialize the ChannelManager
958 EXPECT_CALL(mockSoftbus, Socket(testing::_))
959 .WillRepeatedly(testing::Return(NUM_1234)); // Mock Socket to return a valid socket ID
960 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
961 .WillOnce(testing::Return(ERR_OK)); // Mock Listen to return success
962
963 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
964 EXPECT_EQ(initResult, ERR_OK); // Ensure Init was successful
965
966 // Step 2: Create Client Channel
967 std::string channelName = "TestMessageChannel";
968 ChannelDataType dataType = ChannelDataType::MESSAGE; // Using message type for the data
969 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
970
971 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
972 EXPECT_EQ(channelId, MESSAGE_START_ID); // Verify the channel ID is correctly returned
973
974 // Step 3: Mock Bind to succeed
975 EXPECT_CALL(mockSoftbus, Bind(testing::_, testing::_, testing::_, testing::_))
976 .WillOnce(testing::Return(ERR_OK)); // Mock Bind to succeed
977
978 // Step 4: Call ConnectChannel to establish the connection
979 int32_t result = ChannelManager::GetInstance().ConnectChannel(channelId);
980 EXPECT_EQ(result, ERR_OK); // Verify the connection is established
981
982 // Step 5: Prepare data for message
983 std::shared_ptr<AVTransDataBuffer> dataBuffer = std::make_shared<AVTransDataBuffer>(NUM_1024); // Set buffer size
984 EXPECT_CALL(mockSoftbus, SendMessage(NUM_1234, testing::_, testing::_))
985 .WillOnce(testing::Return(ERR_OK));
986
987 // Step 6: Call SendMessage
988 result = ChannelManager::GetInstance().SendMessage(channelId, dataBuffer);
989 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_FOR_INIT));
990
991 EXPECT_EQ(result, ERR_OK); // Verify that message was sent successfully
992 }
993
994 /**
995 * @tc.name: SendMessage_InvalidChannelId
996 * @tc.desc: Test for SendMessage when channelId is invalid.
997 * @tc.type: FUNC
998 */
999 HWTEST_F(ChannelManagerTest, SendMessage_InvalidChannelId, TestSize.Level1)
1000 {
1001 int32_t invalidChannelId = -1; // Simulating an invalid channelId
1002
1003 // Step 3: Prepare data for message
1004 std::shared_ptr<AVTransDataBuffer> dataBuffer = std::make_shared<AVTransDataBuffer>(NUM_1024); // Set buffer size
1005
1006 // Step 4: Call SendMessage with invalid channelId
1007 int32_t result = ChannelManager::GetInstance().SendMessage(invalidChannelId, dataBuffer);
1008 EXPECT_EQ(result, INVALID_CHANNEL_ID); // Verify that invalid channelId returns INVALID_CHANNEL_ID
1009 }
1010
1011 /**
1012 * @tc.name: SendMessage_NullData
1013 * @tc.desc: Test for SendMessage when data is nullptr.
1014 * @tc.type: FUNC
1015 */
1016 HWTEST_F(ChannelManagerTest, SendMessage_NullData, TestSize.Level1)
1017 {
1018 int32_t result = ChannelManager::GetInstance().SendMessage(MESSAGE_START_ID, nullptr);
1019 EXPECT_EQ(result, INVALID_CHANNEL_ID); // Verify that passing nullptr data returns INVALID_CHANNEL_ID
1020 }
1021
1022 /**
1023 * @tc.name: SendMessage_NotConnect
1024 * @tc.desc: Test for SendMessage when NotConnect
1025 * @tc.type: FUNC
1026 */
1027 HWTEST_F(ChannelManagerTest, SendMessage_NotConnect, TestSize.Level1)
1028 {
1029 // Step 1: Initialize the ChannelManager
1030 EXPECT_CALL(mockSoftbus, Socket(testing::_))
1031 .WillRepeatedly(testing::Return(NUM_1234)); // Mock Socket to return a valid socket ID
1032 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
1033 .WillOnce(testing::Return(ERR_OK)); // Mock Listen to return success
1034
1035 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
1036 EXPECT_EQ(initResult, ERR_OK); // Ensure Init was successful
1037
1038 // Step 2: Create Client Channel
1039 std::string channelName = "TestMessageChannel";
1040 ChannelDataType dataType = ChannelDataType::MESSAGE; // Using message type for the data
1041 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
1042
1043 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
1044 EXPECT_EQ(channelId, MESSAGE_START_ID); // Verify the channel ID is correctly returned
1045
1046 // Step 3: Mock Bind to succeed
1047 EXPECT_CALL(mockSoftbus, Bind(testing::_, testing::_, testing::_, testing::_))
1048 .WillOnce(testing::Return(-1)); // Mock Bind to succeed
1049
1050 // Step 4: Call ConnectChannel to establish the connection
1051 int32_t result = ChannelManager::GetInstance().ConnectChannel(channelId);
1052 EXPECT_EQ(result, CONNECT_CHANNEL_FAILED); // Verify the connection is established
1053
1054 // Step 6: Call SendMessage
1055 result = ChannelManager::GetInstance().SendMessage(channelId, nullptr);
1056 }
1057
1058 /**
1059 * @tc.name: OnMessageReceived_Success_WithCallback
1060 * @tc.desc: Test for OnMessageReceived when the socket is valid and data is received successfully,
1061 * and the OnMessage callback is triggered correctly with the received data.
1062 * @tc.type: FUNC
1063 */
1064 HWTEST_F(ChannelManagerTest, OnMessageReceived_Success_WithCallback, TestSize.Level1)
1065 {
1066 // Step 1: Initialize the ChannelManager
1067 EXPECT_CALL(mockSoftbus, Socket(testing::_))
1068 .WillRepeatedly(testing::Return(NUM_1234)); // 模拟返回一个有效的 socketId
1069 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
1070 .WillOnce(testing::Return(ERR_OK)); // 模拟监听成功
1071
1072 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
1073 EXPECT_EQ(initResult, ERR_OK); // 确保初始化成功
1074
1075 // Step 2: Create a server channel
1076 std::string channelName = "TestChannel"; // 定义测试的通道名称
1077 ChannelDataType dataType = ChannelDataType::MESSAGE; // 设置通道数据类型为 MESSAGE
1078 ChannelPeerInfo peerInfo = { "peerName", "networkId" }; // 创建测试用的 peer 信息
1079 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
1080 EXPECT_EQ(channelId, MESSAGE_START_ID); // 假设 MESSAGE_START_ID 已定义，验证通道创建成功
1081
1082 int32_t socketId = NUM_1234;
1083
1084 // Step 4: Mock the listener and expect the OnMessage callback to be triggered
1085 auto mockListener = std::make_shared<MockChannelListener>();
1086 EXPECT_CALL(*mockListener, OnMessage(channelId, testing::_)).Times(1); // 确保 OnMessage 被调用一次
1087
1088 // 注册监听器
1089 int32_t result = ChannelManager::GetInstance().RegisterChannelListener(channelId, mockListener);
1090 EXPECT_EQ(result, ERR_OK); // 确保注册监听器成功
1091
1092 // Step 5: Prepare test data for OnMessageReceived
1093 const char* testData = "Hello, ChannelManager!"; // 模拟消息数据
1094 uint32_t dataLen = static_cast<uint32_t>(strlen(testData) + 1); // 数据长度，包括结束符
1095
1096 // Step 6: Call OnMessageReceived and expect OnMessage callback
1097 ChannelManager::GetInstance().OnMessageReceived(socketId, testData, dataLen);
1098 }
1099
1100 /**
1101 * @tc.name: OnMessageReceived_Failure_InvalidData
1102 * @tc.desc: Test for OnMessageReceived when invalid data (nullptr or zero length) is provided,
1103 * and the OnError callback is triggered correctly with the appropriate error code.
1104 * @tc.type: FUNC
1105 */
1106 HWTEST_F(ChannelManagerTest, OnMessageReceived_Failure_InvalidData, TestSize.Level1)
1107 {
1108 // Step 1: Initialize the ChannelManager
1109 EXPECT_CALL(mockSoftbus, Socket(testing::_))
1110 .WillRepeatedly(testing::Return(NUM_1234)); // 模拟返回一个有效的 socketId
1111 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
1112 .WillOnce(testing::Return(ERR_OK)); // 模拟监听成功
1113
1114 // 初始化 ChannelManager，验证初始化结果为 ERR_OK
1115 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
1116 EXPECT_EQ(initResult, ERR_OK); // 确保初始化成功
1117
1118 // Step 2: Create a server channel
1119 std::string channelName = "TestChannel";
1120 ChannelDataType dataType = ChannelDataType::MESSAGE;
1121 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
1122 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
1123 EXPECT_EQ(channelId, MESSAGE_START_ID);
1124
1125 int32_t socketId = NUM_1234; // 使用模拟的有效 socketId
1126
1127 // Step 4: Mock the listener and expect the OnError callback to be triggered on failure
1128 auto mockListener = std::make_shared<MockChannelListener>();
1129 EXPECT_CALL(*mockListener, OnMessage(channelId, testing::_)).Times(0);
1130
1131 // 注册监听器
1132 int32_t result = ChannelManager::GetInstance().RegisterChannelListener(channelId, mockListener);
1133 EXPECT_EQ(result, ERR_OK);
1134
1135 // Step 5: Simulate invalid data (nullptr or zero length)
1136 const void* invalidData = nullptr;
1137 uint32_t invalidDataLen = 0;
1138
1139 // Step 6: Call OnMessageReceived with invalid data, expecting an error callback
1140 ChannelManager::GetInstance().OnMessageReceived(socketId, invalidData, invalidDataLen);
1141 }
1142
1143 /**
1144 * @tc.name: OnMessageReceived_InvalidChannelId
1145 * @tc.desc: Test for OnMessageReceived when InvalidChannelId.
1146 * @tc.type: FUNC
1147 */
1148 HWTEST_F(ChannelManagerTest, OnMessageReceived_InvalidChannelId, TestSize.Level1)
1149 {
1150 // Step 1: Initialize the ChannelManager
1151 EXPECT_CALL(mockSoftbus, Socket(testing::_))
1152 .WillRepeatedly(testing::Return(NUM_1234)); // 模拟返回一个有效的 socketId
1153 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
1154 .WillOnce(testing::Return(ERR_OK)); // 模拟监听成功
1155
1156 // 初始化 ChannelManager，验证初始化结果为 ERR_OK
1157 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
1158 EXPECT_EQ(initResult, ERR_OK); // 确保初始化成功
1159
1160 const char* testData = "Hello, ChannelManager!"; // 模拟消息数据
1161 uint32_t dataLen = static_cast<uint32_t>(strlen(testData) + 1); // 数据长度，包括结束符
1162
1163 ChannelManager::GetInstance().OnMessageReceived(NUM_1234, testData, dataLen);
1164 }
1165
1166 /**
1167 * @tc.name: OnStreamReceived_Success
1168 * @tc.desc: Test for OnStreamReceived when valid data is received and processed successfully,
1169 * and the DoStreamReceiveCallback is triggered correctly with the received data.
1170 * @tc.type: FUNC
1171 */
1172 HWTEST_F(ChannelManagerTest, OnStreamReceived_Success, TestSize.Level1)
1173 {
1174 // Step 1: Initialize the ChannelManager
1175 EXPECT_CALL(mockSoftbus, Socket(testing::_))
1176 .WillRepeatedly(testing::Return(NUM_1234)); // 模拟返回一个有效的 socketId
1177 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
1178 .WillOnce(testing::Return(ERR_OK)); // 模拟监听成功
1179
1180 // 初始化 ChannelManager，验证初始化结果为 ERR_OK
1181 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
1182 EXPECT_EQ(initResult, ERR_OK); // 确保初始化成功
1183
1184 // Step 2: Create a server channel
1185 std::string channelName = "TestChannel";
1186 ChannelDataType dataType = ChannelDataType::VIDEO_STREAM;
1187 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
1188 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
1189 EXPECT_EQ(channelId, STREAM_START_ID);
1190
1191 int32_t socketId = NUM_1234;
1192 std::shared_ptr<AVTransDataBuffer> dataBuffer = std::make_shared<AVTransDataBuffer>(NUM_1024);
1193
1194 AVTransStreamDataExt extData;
1195 extData.flag_ = AvCodecBufferFlag::AVCODEC_BUFFER_FLAG_CODEC_DATA;
1196 extData.index_ = NUM_1;
1197 extData.pts_ = NUM_200;
1198 extData.startEncodeT_ = NUM_200;
1199 extData.finishEncodeT_ = NUM_200;
1200 extData.sendEncodeT_ = NUM_200;
1201
1202 std::shared_ptr<AVTransStreamData> streamData = std::make_shared<AVTransStreamData>(dataBuffer, extData);
1203 StreamData data = {
1204 .buf = reinterpret_cast<char*>(streamData->StreamData()->Data()),
1205 .bufLen = streamData->StreamData()->Size()
1206 };
1207 cJSON* extInfo = streamData->SerializeStreamDataExt();
1208 char* jsonString = cJSON_PrintUnformatted(extInfo);
1209 const StreamData ext = {
1210 .buf = jsonString,
1211 .bufLen = strlen(jsonString)
1212 };
1213 StreamFrameInfo param = {
1214 .frameType = NUM_1,
1215 .timeStamp = NUM_200,
1216 .seqNum = NUM_1,
1217 .seqSubNum = NUM_1,
1218 .level = NUM_1,
1219 .bitMap = NUM_1,
1220 .tvCount = NUM_1
1221 };
1222
1223 // Step 4: Mock the listener and expect the DoStreamReceiveCallback to be triggered
1224 auto mockListener = std::make_shared<MockChannelListener>();
1225 EXPECT_CALL(*mockListener, OnStream(channelId, testing::_)).Times(1); // 确保 OnStreamReceived 被调用一次
1226
1227 // 注册监听器
1228 int32_t result = ChannelManager::GetInstance().RegisterChannelListener(channelId, mockListener);
1229 EXPECT_EQ(result, ERR_OK); // 确保注册监听器成功
1230
1231 // Step 5: Call OnStreamReceived and expect the callback
1232 ChannelManager::GetInstance().OnStreamReceived(socketId, &data, &ext, ¶m);
1233 }
1234
1235 /**
1236 * @tc.name: OnStreamReceived_Failure_RecvDataEmpty
1237 * @tc.desc: Test for OnStreamReceived when data copy to buffer fails,
1238 * and the error callback is triggered with RecvDataEmpty.
1239 * @tc.type: FUNC
1240 */
1241 HWTEST_F(ChannelManagerTest, OnStreamReceived_Failure_RecvDataEmpty, TestSize.Level1)
1242 {
1243 // Step 1: Initialize the ChannelManager
1244 EXPECT_CALL(mockSoftbus, Socket(testing::_))
1245 .WillRepeatedly(testing::Return(NUM_1234)); // 模拟返回一个有效的 socketId
1246 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
1247 .WillOnce(testing::Return(ERR_OK)); // 模拟监听成功
1248
1249 // 初始化 ChannelManager，验证初始化结果为 ERR_OK
1250 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
1251 EXPECT_EQ(initResult, ERR_OK); // 确保初始化成功
1252
1253 // Step 2: Create a server channel
1254 std::string channelName = "TestChannel";
1255 ChannelDataType dataType = ChannelDataType::VIDEO_STREAM;
1256 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
1257 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
1258 EXPECT_EQ(channelId, STREAM_START_ID);
1259
1260 int32_t socketId = NUM_1234;
1261 std::shared_ptr<AVTransDataBuffer> dataBuffer = std::make_shared<AVTransDataBuffer>(NUM_1024);
1262
1263 AVTransStreamDataExt extData;
1264 extData.flag_ = AvCodecBufferFlag::AVCODEC_BUFFER_FLAG_CODEC_DATA;
1265 extData.index_ = NUM_1;
1266 extData.pts_ = NUM_200;
1267 extData.startEncodeT_ = NUM_200;
1268 extData.finishEncodeT_ = NUM_200;
1269 extData.sendEncodeT_ = NUM_200;
1270
1271 std::shared_ptr<AVTransStreamData> streamData = std::make_shared<AVTransStreamData>(dataBuffer, extData);
1272 cJSON* extInfo = streamData->SerializeStreamDataExt();
1273 char* jsonString = cJSON_PrintUnformatted(extInfo);
1274 const StreamData ext = {
1275 .buf = jsonString,
1276 .bufLen = strlen(jsonString)
1277 };
1278 StreamFrameInfo param = {
1279 .frameType = NUM_1,
1280 .timeStamp = NUM_200,
1281 .seqNum = NUM_1,
1282 .seqSubNum = NUM_1,
1283 .level = NUM_1,
1284 .bitMap = NUM_1,
1285 .tvCount = NUM_1
1286 };
1287
1288 auto mockListener = std::make_shared<MockChannelListener>();
1289 EXPECT_CALL(*mockListener, OnStream(channelId, testing::_)).Times(0); // 确保 OnStreamReceived 被调用一次
1290
1291 // 注册监听器
1292 int32_t result = ChannelManager::GetInstance().RegisterChannelListener(channelId, mockListener);
1293 EXPECT_EQ(result, ERR_OK); // 确保注册监听器成功
1294
1295 ChannelManager::GetInstance().OnStreamReceived(socketId, nullptr, &ext, ¶m);
1296 }
1297
1298 /**
1299 * @tc.name: OnStreamReceived_Failure_ParseStreamExtFailed
1300 * @tc.desc: Test for OnStreamReceived when parsing the stream extension fails,
1301 * and the error callback is triggered with PARSE_AV_TRANS_STREAM_EXT_FAILED.
1302 * @tc.type: FUNC
1303 */
1304 HWTEST_F(ChannelManagerTest, OnStreamReceived_Failure_ParseStreamExtFailed, TestSize.Level1)
1305 {
1306 // Step 1: Initialize the ChannelManager
1307 EXPECT_CALL(mockSoftbus, Socket(testing::_))
1308 .WillRepeatedly(testing::Return(NUM_1234)); // 模拟返回一个有效的 socketId
1309 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
1310 .WillOnce(testing::Return(ERR_OK)); // 模拟监听成功
1311
1312 // 初始化 ChannelManager，验证初始化结果为 ERR_OK
1313 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
1314 EXPECT_EQ(initResult, ERR_OK); // 确保初始化成功
1315
1316 // Step 2: Create a server channel
1317 std::string channelName = "TestChannel";
1318 ChannelDataType dataType = ChannelDataType::VIDEO_STREAM;
1319 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
1320 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
1321 EXPECT_EQ(channelId, STREAM_START_ID);
1322
1323 int32_t socketId = NUM_1234;
1324 std::shared_ptr<AVTransDataBuffer> dataBuffer = std::make_shared<AVTransDataBuffer>(NUM_1024);
1325
1326 AVTransStreamDataExt extData;
1327 extData.flag_ = AvCodecBufferFlag::AVCODEC_BUFFER_FLAG_CODEC_DATA;
1328 extData.index_ = NUM_1;
1329 extData.pts_ = NUM_200;
1330 extData.startEncodeT_ = NUM_200;
1331 extData.finishEncodeT_ = NUM_200;
1332 extData.sendEncodeT_ = NUM_200;
1333
1334 std::shared_ptr<AVTransStreamData> streamData = std::make_shared<AVTransStreamData>(dataBuffer, extData);
1335 StreamData data = {
1336 .buf = reinterpret_cast<char*>(streamData->StreamData()->Data()),
1337 .bufLen = streamData->StreamData()->Size()
1338 };
1339 const StreamData ext = {
1340 .buf = nullptr,
1341 .bufLen = NUM_1
1342 };
1343 StreamFrameInfo param = {
1344 .frameType = NUM_1,
1345 .timeStamp = NUM_200,
1346 .seqNum = NUM_1,
1347 .seqSubNum = NUM_1,
1348 .level = NUM_1,
1349 .bitMap = NUM_1,
1350 .tvCount = NUM_1
1351 };
1352
1353 // 模拟反序列化失败
1354 auto mockListener = std::make_shared<MockChannelListener>();
1355 EXPECT_CALL(*mockListener, OnStream(channelId, testing::_)).Times(0); // 确保 OnStreamReceived 被调用一次
1356
1357 // 注册监听器
1358 int32_t result = ChannelManager::GetInstance().RegisterChannelListener(channelId, mockListener);
1359 EXPECT_EQ(result, ERR_OK); // 确保注册监听器成功
1360
1361 // Step 4: Call OnStreamReceived and expect error callback to be triggered
1362 ChannelManager::GetInstance().OnStreamReceived(socketId, &data, &ext, ¶m);
1363 }
1364
1365 /**
1366 * @tc.name: OnBytesReceived_Success
1367 * @tc.desc: Test for OnBytesReceived when valid data is received and processed successfully,
1368 * and the DoBytesReceiveCallback is triggered correctly with the processed data.
1369 * @tc.type: FUNC
1370 */
1371 HWTEST_F(ChannelManagerTest, OnBytesReceived_Success, TestSize.Level1)
1372 {
1373 // Step 1: Initialize the ChannelManager
1374 EXPECT_CALL(mockSoftbus, Socket(testing::_))
1375 .WillRepeatedly(testing::Return(NUM_1234)); // 模拟返回一个有效的 socketId
1376 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
1377 .WillOnce(testing::Return(ERR_OK)); // 模拟监听成功
1378
1379 // 初始化 ChannelManager，验证初始化结果为 ERR_OK
1380 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
1381 EXPECT_EQ(initResult, ERR_OK); // 确保初始化成功
1382
1383 // Step 2: Create a server channel
1384 std::string channelName = "TestChannel";
1385 ChannelDataType dataType = ChannelDataType::BYTES;
1386 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
1387 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
1388 EXPECT_EQ(channelId, BYTES_START_ID);
1389
1390 int32_t socketId = NUM_1234;
1391
1392 // Step 3: Prepare test data for OnBytesReceived
1393 auto buffer = std::make_unique<AVTransDataBuffer>(NUM_1024);
1394 uint32_t dataLen = buffer->Size();
1395
1396 // 构造发送的数据包头（使用 SessionDataHeader 格式）
1397 SessionDataHeader headerPara(
1398 NUM_1,
1399 FRAG_TYPE::FRAG_START_END,
1400 static_cast<int32_t>(ChannelDataType::BYTES), // 这里的 dataType 应该与发送的数据类型一致
1401 0, // seqNum
1402 dataLen + SessionDataHeader::HEADER_LEN, // totalLen
1403 dataLen + SessionDataHeader::HEADER_LEN, // packetLen
1404 dataLen, // payloadLen
1405 0 // subSeq
1406 );
1407
1408 auto headerBuffer = headerPara.Serialize();
1409 auto sendBuffer = std::make_unique<AVTransDataBuffer>(SessionDataHeader::HEADER_LEN + dataLen);
1410 uint8_t* header = sendBuffer->Data();
1411
1412 // copy header
1413 memcpy_s(header, sendBuffer->Size(),
1414 headerBuffer->Data(), SessionDataHeader::HEADER_LEN);
1415
1416 // copy data
1417 memcpy_s(header + SessionDataHeader::HEADER_LEN,
1418 sendBuffer->Size() - SessionDataHeader::HEADER_LEN,
1419 buffer->Data(), dataLen);
1420
1421 // Step 4: Prepare the mock listener for verifying callback
1422 auto mockListener = std::make_shared<MockChannelListener>();
1423 EXPECT_CALL(*mockListener, OnBytes(channelId, testing::_)).Times(1); // 确保回调被调用一次
1424
1425 // 注册监听器
1426 int32_t result = ChannelManager::GetInstance().RegisterChannelListener(channelId, mockListener);
1427 EXPECT_EQ(result, ERR_OK); // 确保注册监听器成功
1428
1429 // Step 5: Call OnBytesReceived and expect the callback
1430 ChannelManager::GetInstance().OnBytesReceived(socketId, header, dataLen);
1431 }
1432
1433 /**
1434 * @tc.name: OnBytesReceived_Failure_DataEmpty
1435 * @tc.desc: Test for OnBytesReceived when an invalid channel ID is provided,
1436 * and the error callback is triggered with DataEmpty.
1437 * @tc.type: FUNC
1438 */
1439 HWTEST_F(ChannelManagerTest, OnBytesReceived_Failure_DataEmpty, TestSize.Level1)
1440 {
1441 // Step 1: Initialize the ChannelManager
1442 EXPECT_CALL(mockSoftbus, Socket(testing::_))
1443 .WillRepeatedly(testing::Return(NUM_1234)); // 模拟返回一个有效的 socketId
1444 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
1445 .WillOnce(testing::Return(ERR_OK)); // 模拟监听成功
1446
1447 // 初始化 ChannelManager，验证初始化结果为 ERR_OK
1448 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
1449 EXPECT_EQ(initResult, ERR_OK); // 确保初始化成功
1450
1451 // Step 2: Create a server channel
1452 std::string channelName = "TestChannel";
1453 ChannelDataType dataType = ChannelDataType::BYTES;
1454 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
1455 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
1456 EXPECT_EQ(channelId, BYTES_START_ID);
1457
1458 int32_t socketId = NUM_1234;
1459
1460 // Step 4: Prepare the mock listener for verifying callback
1461 auto mockListener = std::make_shared<MockChannelListener>();
1462 EXPECT_CALL(*mockListener, OnBytes(channelId, testing::_)).Times(0); // 确保回调被调用一次
1463
1464 // 注册监听器
1465 int32_t result = ChannelManager::GetInstance().RegisterChannelListener(channelId, mockListener);
1466 EXPECT_EQ(result, ERR_OK); // 确保注册监听器成功
1467
1468 // Step 4: Mock error callback for invalid channelId
1469
1470 // Step 5: Call OnBytesReceived with invalid channelId and expect error callback
1471 ChannelManager::GetInstance().OnBytesReceived(socketId, nullptr, NUM_1024);
1472 }
1473
1474 /**
1475 * @tc.name: OnBytesReceived_Failure_PackRecvPacketDataFailed
1476 * @tc.desc: Test for OnBytesReceived when the packet data processing fails in ProcessRecvData,
1477 * and the error callback is triggered with the appropriate error code.
1478 * @tc.type: FUNC
1479 */
1480 HWTEST_F(ChannelManagerTest, OnBytesReceived_Failure_PackRecvPacketDataFailed, TestSize.Level1)
1481 {
1482 // Step 1: Initialize the ChannelManager
1483 EXPECT_CALL(mockSoftbus, Socket(testing::_))
1484 .WillRepeatedly(testing::Return(NUM_1234)); // 模拟返回一个有效的 socketId
1485 EXPECT_CALL(mockSoftbus, Listen(testing::_, testing::_, testing::_, testing::_))
1486 .WillOnce(testing::Return(ERR_OK)); // 模拟监听成功
1487
1488 // 初始化 ChannelManager，验证初始化结果为 ERR_OK
1489 int32_t initResult = ChannelManager::GetInstance().Init(ownerName);
1490 EXPECT_EQ(initResult, ERR_OK); // 确保初始化成功
1491
1492 // Step 2: Create a server channel
1493 std::string channelName = "TestChannel";
1494 ChannelDataType dataType = ChannelDataType::BYTES;
1495 ChannelPeerInfo peerInfo = { "peerName", "networkId" };
1496 int32_t channelId = ChannelManager::GetInstance().CreateClientChannel(channelName, dataType, peerInfo);
1497 EXPECT_EQ(channelId, BYTES_START_ID);
1498
1499 int32_t socketId = NUM_1234;
1500 auto buffer = std::make_unique<AVTransDataBuffer>(NUM_1024);
1501 uint32_t dataLen = buffer->Size();
1502 // Step 3: Prepare test data for OnBytesReceived
1503 SessionDataHeader headerPara(
1504 NUM_1,
1505 FRAG_TYPE::FRAG_START_END,
1506 static_cast<int32_t>(ChannelDataType::BYTES), // 这里的 dataType 应该与发送的数据类型一致
1507 10, // seqNum
1508 dataLen + SessionDataHeader::HEADER_LEN, // totalLen
1509 dataLen + SessionDataHeader::HEADER_LEN, // packetLen
1510 dataLen, // payloadLen
1511 0 // subSeq
1512 );
1513
1514 auto headerBuffer = headerPara.Serialize();
1515 auto sendBuffer = std::make_unique<AVTransDataBuffer>(SessionDataHeader::HEADER_LEN + dataLen);
1516 uint8_t* header = sendBuffer->Data();
1517
1518 // copy header
1519 memcpy_s(header, sendBuffer->Size(),
1520 headerBuffer->Data(), SessionDataHeader::HEADER_LEN);
1521
1522 // copy data
1523 memcpy_s(header + SessionDataHeader::HEADER_LEN,
1524 sendBuffer->Size() - SessionDataHeader::HEADER_LEN,
1525 buffer->Data(), dataLen);
1526
1527 // Step 4: Prepare the mock listener for verifying callback
1528 auto mockListener = std::make_shared<MockChannelListener>();
1529 EXPECT_CALL(*mockListener, OnBytes(channelId, testing::_)).Times(0); // 确保回调被调用一次
1530
1531 // 注册监听器
1532 int32_t result = ChannelManager::GetInstance().RegisterChannelListener(channelId, mockListener);
1533 EXPECT_EQ(result, ERR_OK); // 确保注册监听器成功
1534 // Step 5: Simulate failure in `PackRecvPacketData` and call OnBytesReceived
1535 ChannelManager::GetInstance().OnBytesReceived(socketId, header, dataLen);
1536 }
1537
1538 /**
1539 * @tc.name: SendFile_Failed_001
1540 * @tc.desc: Test for SendBytes when both channel and connection are successfully established.
1541 * @tc.type: FUNC
1542 */
1543 HWTEST_F(ChannelManagerTest, SendFile_Failed_001, TestSize.Level1)
1544 {
1545 int32_t channelId = ChannelManager::CHANNEL_ID_GAP;
1546 std::vector<std::string> sFiles;
1547 std::vector<std::string> dFiles;
1548
1549 auto ret = ChannelManager::GetInstance().SendFile(channelId, sFiles, dFiles);
1550 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1551
1552 channelId = ChannelManager::FILE_START_ID + ChannelManager::CHANNEL_ID_GAP + 1;
1553 ret = ChannelManager::GetInstance().SendFile(channelId, sFiles, dFiles);
1554 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1555
1556 channelId = ChannelManager::CHANNEL_ID_GAP + 1;
1557 ret = ChannelManager::GetInstance().SendFile(channelId, sFiles, dFiles);
1558 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1559
1560 sFiles.push_back("test");
1561 ret = ChannelManager::GetInstance().SendFile(channelId, sFiles, dFiles);
1562 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
1563
1564 dFiles.push_back("test");
1565 ret = ChannelManager::GetInstance().SendFile(channelId, sFiles, dFiles);
1566 EXPECT_NE(ret, ERR_OK);
1567
1568 std::vector<std::string> sFile(ChannelManager::MAX_FILE_COUNT + 1, "test");
1569 std::vector<std::string> dFile(ChannelManager::MAX_FILE_COUNT + 1, "test");
1570 ret = ChannelManager::GetInstance().SendFile(channelId, sFile, dFile);
1571 EXPECT_NE(ret, ERR_OK);
1572 }
1573
1574 /**
1575 * @tc.name: OnMessageReceived_Failed_001
1576 * @tc.desc: Test for SendBytes when both channel and connection are successfully established.
1577 * @tc.type: FUNC
1578 */
1579 HWTEST_F(ChannelManagerTest, OnMessageReceived_Failed_001, TestSize.Level1)
1580 {
1581 int32_t socketId = -1;
1582 char *data = nullptr;
1583 uint32_t dataLen = 0;
1584
1585 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().OnMessageReceived(socketId, data, dataLen));
1586 socketId = 1;
1587 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().OnMessageReceived(socketId, data, dataLen));
1588
1589 SessionDataHeader sessionData;
1590 auto avData = sessionData.Serialize();
1591 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().OnMessageReceived(socketId, avData->Data(), dataLen));
1592 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().OnMessageReceived(
1593 socketId, avData->Data(), avData->Size()));
1594 dataLen = MAX_LEN + 1;
1595 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().OnMessageReceived(socketId, avData->Data(), dataLen));
1596 }
1597
1598 /**
1599 * @tc.name: DispatchProcessFileEvent_001
1600 * @tc.desc: Test for DispatchProcessFileEvent
1601 * @tc.type: FUNC
1602 */
1603 HWTEST_F(ChannelManagerTest, DispatchProcessFileEvent_001, TestSize.Level1)
1604 {
1605 int32_t channelId = 30;
1606 FileEvent event;
1607 event.type = FileEventType::FILE_EVENT_SEND_PROCESS;
1608 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().DispatchProcessFileEvent(channelId, &event));
1609
1610 event.type = FileEventType::FILE_EVENT_SEND_FINISH;
1611 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().DispatchProcessFileEvent(channelId, &event));
1612
1613 event.type = FileEventType::FILE_EVENT_SEND_PROCESS;
1614 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().DispatchProcessFileEvent(channelId, &event));
1615
1616 event.type = FileEventType::FILE_EVENT_RECV_START;
1617 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().DispatchProcessFileEvent(channelId, &event));
1618
1619 event.type = FileEventType::FILE_EVENT_RECV_PROCESS;
1620 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().DispatchProcessFileEvent(channelId, &event));
1621
1622 event.type = FileEventType::FILE_EVENT_RECV_FINISH;
1623 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().DispatchProcessFileEvent(channelId, &event));
1624
1625 event.type = FileEventType::FILE_EVENT_BUTT;
1626 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().DispatchProcessFileEvent(channelId, &event));
1627
1628 event.type = FileEventType::FILE_EVENT_SEND_ERROR;
1629 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().DispatchProcessFileEvent(channelId, &event));
1630
1631 event.type = FileEventType::FILE_EVENT_RECV_ERROR;
1632 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().DispatchProcessFileEvent(channelId, &event));
1633
1634 event.type = FileEventType::FILE_EVENT_RECV_UPDATE_PATH;
1635 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().DispatchProcessFileEvent(channelId, &event));
1636
1637 int32_t validType = 999999;
1638 event.type = static_cast<FileEventType>(validType);
1639 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().DispatchProcessFileEvent(channelId, &event));
1640 }
1641
1642 /**
1643 * @tc.name: OnFileEventReceived_001
1644 * @tc.desc: Test for OnFileEventReceived
1645 * @tc.type: FUNC
1646 */
1647 HWTEST_F(ChannelManagerTest, OnFileEventReceived_001, TestSize.Level1)
1648 {
1649 int32_t socketId = -1;
1650 FileEvent *pEvent = nullptr;
1651 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().OnFileEventReceived(socketId, pEvent));
1652
1653 socketId = 1;
1654 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().OnFileEventReceived(socketId, pEvent));
1655
1656 FileEvent event;
1657 event.type = FileEventType::FILE_EVENT_RECV_UPDATE_PATH;
1658 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().OnFileEventReceived(socketId, &event));
1659
1660 event.type = FileEventType::FILE_EVENT_SEND_PROCESS;
1661 EXPECT_NO_FATAL_FAILURE(ChannelManager::GetInstance().OnFileEventReceived(socketId, &event));
1662 }
1663 } // namespace DistributedCollab
1664 } // namespace OHOS
1665