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