1 /*
2  * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 
18 #include <securec.h>
19 #define private public
20 #include "dcamera_softbus_adapter.h"
21 #undef private
22 
23 #include "data_buffer.h"
24 #include "dcamera_softbus_session.h"
25 #include "dcamera_hisysevent_adapter.h"
26 #include "distributed_camera_constants.h"
27 #include "distributed_camera_errno.h"
28 #include "session_bus_center.h"
29 
30 using namespace testing::ext;
31 
32 namespace OHOS {
33 namespace DistributedHardware {
34 class DCameraSoftbusAdapterTest : public testing::Test {
35 public:
36     static void SetUpTestCase(void);
37     static void TearDownTestCase(void);
38     void SetUp();
39     void TearDown();
40 };
41 
42 namespace {
43 const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7";
44 const std::string TEST_CAMERA_DH_ID_0 = "camera_0";
45 }
46 
SetUpTestCase(void)47 void DCameraSoftbusAdapterTest::SetUpTestCase(void)
48 {
49 }
50 
TearDownTestCase(void)51 void DCameraSoftbusAdapterTest::TearDownTestCase(void)
52 {
53 }
54 
SetUp(void)55 void DCameraSoftbusAdapterTest::SetUp(void)
56 {
57 }
58 
TearDown(void)59 void DCameraSoftbusAdapterTest::TearDown(void)
60 {
61 }
62 
63 /**
64  * @tc.name: dcamera_softbus_adapter_test_001
65  * @tc.desc: Verify the CreateSoftbusSessionServer function.
66  * @tc.type: FUNC
67  * @tc.require:
68  */
69 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_001, TestSize.Level1)
70 {
71     std::string sessionName = "sourcetest01";
72     std::string peerSessionName = "dh_control_0";
73     std::string peerDevId = "abcd";
74     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
75     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_CTRL;
76     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreatSoftBusSinkSocketServer(sessionName, role,
77         sessionMode, peerDevId, peerSessionName);
78     EXPECT_EQ(DCAMERA_OK, ret);
79 }
80 
81 /**
82  * @tc.name: dcamera_softbus_adapter_test_002
83  * @tc.desc: Verify the DestroySoftbusSessionServer function.
84  * @tc.type: FUNC
85  * @tc.require:
86  */
87 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_002, TestSize.Level1)
88 {
89     std::string sessionName = "sourcetest02";
90     std::string peerSessionName = "dh_control_0";
91     std::string peerDevId = "abcd";
92     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
93     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_CTRL;
94     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreatSoftBusSinkSocketServer(sessionName, role,
95         sessionMode, peerDevId, peerSessionName);
96     ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
97     EXPECT_EQ(DCAMERA_OK, ret);
98 }
99 
100 /**
101  * @tc.name: dcamera_softbus_adapter_test_003
102  * @tc.desc: Verify the DestroySoftbusSessionServer function.
103  * @tc.type: FUNC
104  * @tc.require:
105  */
106 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_003, TestSize.Level1)
107 {
108     std::string sessionName = "sourcetest03";
109     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
110     std::string mySessName = "sourcetest03";
111     std::string peerSessName = "sinktest02";
112     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_CTRL;
113     std::string peerDevId = TEST_DEVICE_ID;
114     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreatSoftBusSinkSocketServer(mySessName, role,
115         sessionMode, peerDevId, peerSessName);
116     DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
117     EXPECT_EQ(DCAMERA_OK, ret);
118 }
119 
120 /**
121  * @tc.name: dcamera_softbus_adapter_test_004
122  * @tc.desc: Verify the DestroySoftbusSessionServer function.
123  * @tc.type: FUNC
124  * @tc.require:
125  */
126 
127 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_004, TestSize.Level1)
128 {
129     std::string sessionName = "sourcetest04";
130     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
131     std::string mySessName = "sourcetest04";
132     std::string peerSessName = "sinktest02";
133     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_CTRL;
134     std::string peerDevId = TEST_DEVICE_ID;
135     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreatSoftBusSinkSocketServer(mySessName, role,
136         sessionMode, peerDevId, peerSessName);
137     int32_t sessionId = 1;
138     ret = DCameraSoftbusAdapter::GetInstance().CloseSoftbusSession(sessionId);
139     DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
140     EXPECT_EQ(DCAMERA_OK, ret);
141 }
142 
143 /**
144  * @tc.name: dcamera_softbus_adapter_test_005
145  * @tc.desc: Verify the SendSofbusBytes function.
146  * @tc.type: FUNC
147  * @tc.require:
148  */
149 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_005, TestSize.Level1)
150 {
151     std::string sessionName = "sourcetest03";
152     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
153     std::string mySessName = "sourcetest03";
154     std::string peerSessName = "sinktest02";
155     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_CTRL;
156     std::string peerDevId = TEST_DEVICE_ID;
157     std::string myDevId = "abcde";
158     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
159         sessionMode, role);
160     size_t capacity = 1;
161     std::shared_ptr<DataBuffer> dataBuffer = std::make_shared<DataBuffer>(capacity);
162     int32_t sessionId = 2;
163     ret = DCameraSoftbusAdapter::GetInstance().SendSofbusBytes(sessionId, dataBuffer);
164     DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
165     EXPECT_EQ(DCAMERA_OK, ret);
166 }
167 
168 /**
169  * @tc.name: dcamera_softbus_adapter_test_006
170  * @tc.desc: Verify the SendSofbusStream function.
171  * @tc.type: FUNC
172  * @tc.require:
173  */
174 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_006, TestSize.Level1)
175 {
176     std::string sessionName = "sourcetest03";
177     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
178     std::string mySessName = "sourcetest03";
179     std::string peerSessName = "sinktest02";
180     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_VIDEO;
181     std::string peerDevId = TEST_DEVICE_ID;
182     std::string myDevId = "abcde";
183     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
184         sessionMode, role);
185     size_t capacity = 1;
186     std::shared_ptr<DataBuffer> dataBuffer = std::make_shared<DataBuffer>(capacity);
187     int32_t sessionId = 2;
188     ret = DCameraSoftbusAdapter::GetInstance().SendSofbusStream(sessionId, dataBuffer);
189     dataBuffer->SetInt64(TIME_STAMP_US, 1);
190     ret = DCameraSoftbusAdapter::GetInstance().SendSofbusStream(sessionId, dataBuffer);
191     DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
192     EXPECT_EQ(DCAMERA_OK, ret);
193 }
194 
195 /**
196  * @tc.name: dcamera_softbus_adapter_test_007
197  * @tc.desc: Verify the GetLocalNetworkId function.
198  * @tc.type: FUNC
199  * @tc.require:
200  */
201 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_007, TestSize.Level1)
202 {
203     std::string devId = TEST_DEVICE_ID;
204     int32_t ret = DCameraSoftbusAdapter::GetInstance().GetLocalNetworkId(devId);
205     EXPECT_EQ(DCAMERA_OK, ret);
206 }
207 
208 /**
209  * @tc.name: dcamera_softbus_adapter_test_008
210  * @tc.desc: Verify the OnSourceSessionOpened function.
211  * @tc.type: FUNC
212  * @tc.require:
213  */
214 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_008, TestSize.Level1)
215 {
216     std::string sessionName = "sourcetest03";
217     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
218     std::string mySessName = "sourcetest03";
219     std::string peerSessName = "sinktest02";
220     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_VIDEO;
221     std::string peerDevId = TEST_DEVICE_ID;
222     std::string myDevId = "abcde";
223     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
224         sessionMode, role);
225     int32_t sessionId = 2;
226     PeerSocketInfo info = {
227         .name = const_cast<char*>(peerSessName.c_str()),
228         .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
229         .networkId = const_cast<char*>(peerDevId.c_str()),
230         .dataType = TransDataType::DATA_TYPE_VIDEO_STREAM,
231     };
232     std::shared_ptr<DCameraSoftbusSession> session = std::make_shared<DCameraSoftbusSession>();
233     DCameraSoftbusAdapter::GetInstance().sourceSessions_.emplace(peerDevId + mySessName, session);
234     ret = DCameraSoftbusAdapter::GetInstance().SourceOnBind(sessionId, info);
235     DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
236     EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
237 }
238 
239 /**
240  * @tc.name: dcamera_softbus_adapter_test_009
241  * @tc.desc: Verify the OnSourceSessionClosed function.
242  * @tc.type: FUNC
243  * @tc.require:
244  */
245 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_009, TestSize.Level1)
246 {
247     std::string sessionName = "sourcetest03";
248     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
249     std::string mySessName = "sourcetest03";
250     std::string peerSessName = "sinktest02";
251     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_VIDEO;
252     std::string peerDevId = TEST_DEVICE_ID;
253     std::string myDevId = "abcde";
254     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
255         sessionMode, role);
256     int32_t sessionId = 2;
257     PeerSocketInfo info = {
258         .name = const_cast<char*>(peerSessName.c_str()),
259         .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
260         .networkId = const_cast<char*>(peerDevId.c_str()),
261         .dataType = TransDataType::DATA_TYPE_VIDEO_STREAM,
262     };
263     DCameraSoftbusAdapter::GetInstance().SourceOnBind(sessionId, info);
264 
265     DCameraSoftbusAdapter::GetInstance().SourceOnShutDown(sessionId, ShutdownReason::SHUTDOWN_REASON_LOCAL);
266     ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
267     EXPECT_EQ(DCAMERA_OK, ret);
268 }
269 
270 /**
271  * @tc.name: dcamera_softbus_adapter_test_010
272  * @tc.desc: Verify the OnSourceBytesReceived function.
273  * @tc.type: FUNC
274  * @tc.require:
275  */
276 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_010, TestSize.Level1)
277 {
278     std::string sessionName = "sourcetest03";
279     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
280     std::string mySessName = "sourcetest03";
281     std::string peerSessName = "sinktest02";
282     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_VIDEO;
283     std::string peerDevId = TEST_DEVICE_ID;
284     std::string myDevId = "abcde";
285     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
286         sessionMode, role);
287     int32_t sessionId = 2;
288     PeerSocketInfo info = {
289         .name = const_cast<char*>(peerSessName.c_str()),
290         .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
291         .networkId = const_cast<char*>(peerDevId.c_str()),
292         .dataType = TransDataType::DATA_TYPE_VIDEO_STREAM,
293     };
294     ret = DCameraSoftbusAdapter::GetInstance().SourceOnBind(sessionId, info);
295     const void *data = "testdata";
296     uint32_t dataLen = 8;
297     DCameraSoftbusAdapter::GetInstance().SourceOnBytes(sessionId, data, dataLen);
298     DCameraSoftbusAdapter::GetInstance().SourceOnShutDown(sessionId, ShutdownReason::SHUTDOWN_REASON_LOCAL);
299     ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
300     EXPECT_EQ(DCAMERA_OK, ret);
301 }
302 
303 /**
304  * @tc.name: dcamera_softbus_adapter_test_011
305  * @tc.desc: Verify the OnSourceBytesReceived function.
306  * @tc.type: FUNC
307  * @tc.require:
308  */
309 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_011, TestSize.Level1)
310 {
311     std::string sessionName = "sourcetest03";
312     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
313     std::string mySessName = "sourcetest03";
314     std::string peerSessName = "sinktest02";
315     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_VIDEO;
316     std::string peerDevId = TEST_DEVICE_ID;
317     std::string myDevId = "abcde";
318     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
319         sessionMode, role);
320     int32_t sessionId = 2;
321     PeerSocketInfo info = {
322         .name = const_cast<char*>(peerSessName.c_str()),
323         .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
324         .networkId = const_cast<char*>(peerDevId.c_str()),
325         .dataType = TransDataType::DATA_TYPE_VIDEO_STREAM,
326     };
327     ret = DCameraSoftbusAdapter::GetInstance().SourceOnBind(sessionId, info);
328     const void *data = "testdata";
329     uint32_t dataLen = 8;
330     DCameraSoftbusAdapter::GetInstance().SourceOnMessage(sessionId, data, dataLen);
331     DCameraSoftbusAdapter::GetInstance().SourceOnShutDown(sessionId, ShutdownReason::SHUTDOWN_REASON_LOCAL);
332     ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
333     EXPECT_EQ(DCAMERA_OK, ret);
334 }
335 
336 /**
337  * @tc.name: dcamera_softbus_adapter_test_012
338  * @tc.desc: Verify the OnSourceBytesReceived function.
339  * @tc.type: FUNC
340  * @tc.require:
341  */
342 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_012, TestSize.Level1)
343 {
344     std::string sessionName = "sourcetest03";
345     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
346     std::string mySessName = "sourcetest03";
347     std::string peerSessName = "sinktest02";
348     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_VIDEO;
349     std::string peerDevId = TEST_DEVICE_ID;
350     std::string myDevId = "abcde";
351     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
352         sessionMode, role);
353     int32_t sessionId = 2;
354     PeerSocketInfo info = {
355         .name = const_cast<char*>(peerSessName.c_str()),
356         .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
357         .networkId = const_cast<char*>(peerDevId.c_str()),
358         .dataType = TransDataType::DATA_TYPE_VIDEO_STREAM,
359     };
360     ret = DCameraSoftbusAdapter::GetInstance().SourceOnBind(sessionId, info);
361     std::string buff01 = "testbuffer01";
362     StreamData test01;
363     test01.buf = const_cast<char *>(buff01.c_str());
364     test01.bufLen = buff01.size();
365     StreamData test02;
366     std::string buff02 = "testbuffer01";
367     test02.buf = const_cast<char *>(buff02.c_str());
368     test02.bufLen = buff02.size();
369     StreamFrameInfo param01;
370     StreamData *data = &test01;
371     StreamData *ext = &test02;
372     StreamFrameInfo *param = &param01;
373     DCameraSoftbusAdapter::GetInstance().SourceOnStream(sessionId, data, ext, param);
374     data = nullptr;
375     DCameraSoftbusAdapter::GetInstance().SourceOnStream(sessionId, data, ext, param);
376     StreamData test03;
377     test01.buf = const_cast<char *>(buff01.c_str());
378     test01.bufLen = 0;
379     data = &test03;
380     DCameraSoftbusAdapter::GetInstance().SourceOnStream(sessionId, data, ext, param);
381     DCameraSoftbusAdapter::GetInstance().SourceOnShutDown(sessionId, ShutdownReason::SHUTDOWN_REASON_LOCAL);
382     ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
383     EXPECT_EQ(DCAMERA_OK, ret);
384 }
385 
386 /**
387  * @tc.name: dcamera_softbus_adapter_test_012
388  * @tc.desc: Verify the OnSinkSessionOpened function.
389  * @tc.type: FUNC
390  * @tc.require:
391  */
392 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_013, TestSize.Level1)
393 {
394     std::string sessionName = "sourcetest013";
395     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
396     std::string mySessName = "sourcetest013";
397     std::string peerSessName = "sinktest012";
398     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_VIDEO;
399     std::string peerDevId = TEST_DEVICE_ID;
400     std::string myDevId = "abcde";
401     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
402         sessionMode, role);
403     int32_t sessionId = 2;
404     PeerSocketInfo info = {
405         .name = const_cast<char*>(peerSessName.c_str()),
406         .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
407         .networkId = const_cast<char*>(peerDevId.c_str()),
408         .dataType = TransDataType::DATA_TYPE_VIDEO_STREAM,
409     };
410     std::shared_ptr<DCameraSoftbusSession> session = std::make_shared<DCameraSoftbusSession>();
411     DCameraSoftbusAdapter::GetInstance().sinkSessions_.emplace(peerDevId + mySessName, session);
412     ret = DCameraSoftbusAdapter::GetInstance().SinkOnBind(sessionId, info);
413     DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
414     EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
415 }
416 /**
417  * @tc.name: dcamera_softbus_adapter_test_014
418  * @tc.desc: Verify the OnSinkSessionClosed function.
419  * @tc.type: FUNC
420  * @tc.require:
421  */
422 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_014, TestSize.Level1)
423 {
424     std::string sessionName = "sourcetest013";
425     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
426     std::string mySessName = "sourcetest013";
427     std::string peerSessName = "sinktest012";
428     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_VIDEO;
429     std::string peerDevId = TEST_DEVICE_ID;
430     std::string myDevId = "abcde";
431     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
432         sessionMode, role);
433     int32_t sessionId = 2;
434     PeerSocketInfo info = {
435         .name = const_cast<char*>(peerSessName.c_str()),
436         .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
437         .networkId = const_cast<char*>(peerDevId.c_str()),
438         .dataType = TransDataType::DATA_TYPE_VIDEO_STREAM,
439     };
440     DCameraSoftbusAdapter::GetInstance().SinkOnBind(sessionId, info);
441 
442     DCameraSoftbusAdapter::GetInstance().SinkOnShutDown(sessionId, ShutdownReason::SHUTDOWN_REASON_LOCAL);
443     ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
444     EXPECT_EQ(DCAMERA_OK, ret);
445 }
446 
447 /**
448  * @tc.name: dcamera_softbus_adapter_test_015
449  * @tc.desc: Verify the OnSinkBytesReceived function.
450  * @tc.type: FUNC
451  * @tc.require:
452  */
453 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_015, TestSize.Level1)
454 {
455     std::string sessionName = "sourcetest013";
456     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
457     std::string mySessName = "sourcetest013";
458     std::string peerSessName = "sinktest012";
459     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_CTRL;
460     std::string peerDevId = TEST_DEVICE_ID;
461     std::string myDevId = "abcde";
462     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
463         sessionMode, role);
464     int32_t sessionId = 2;
465     PeerSocketInfo info = {
466         .name = const_cast<char*>(peerSessName.c_str()),
467         .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
468         .networkId = const_cast<char*>(peerDevId.c_str()),
469         .dataType = TransDataType::DATA_TYPE_BYTES,
470     };
471     ret = DCameraSoftbusAdapter::GetInstance().SinkOnBind(sessionId, info);
472     const void *data = "testdata";
473     uint32_t dataLen = 8;
474     DCameraSoftbusAdapter::GetInstance().SinkOnBytes(sessionId, data, dataLen);
475     DCameraSoftbusAdapter::GetInstance().SinkOnShutDown(sessionId, ShutdownReason::SHUTDOWN_REASON_LOCAL);
476     ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
477     EXPECT_EQ(DCAMERA_OK, ret);
478 }
479 
480 /**
481  * @tc.name: dcamera_softbus_adapter_test_016
482  * @tc.desc: Verify the OnSinkMessageReceived function.
483  * @tc.type: FUNC
484  * @tc.require:
485  */
486 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_016, TestSize.Level1)
487 {
488     std::string sessionName = "sourcetest013";
489     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
490     std::string mySessName = "sourcetest013";
491     std::string peerSessName = "sinktest012";
492     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_CTRL;
493     std::string peerDevId = TEST_DEVICE_ID;
494     std::string myDevId = "abcde";
495     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
496         sessionMode, role);
497     int32_t sessionId = 2;
498     PeerSocketInfo info = {
499         .name = const_cast<char*>(peerSessName.c_str()),
500         .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
501         .networkId = const_cast<char*>(peerDevId.c_str()),
502         .dataType = TransDataType::DATA_TYPE_BYTES,
503     };
504     ret = DCameraSoftbusAdapter::GetInstance().SinkOnBind(sessionId, info);
505     const void *data = "testdata";
506     uint32_t dataLen = 8;
507     DCameraSoftbusAdapter::GetInstance().SinkOnMessage(sessionId, data, dataLen);
508     DCameraSoftbusAdapter::GetInstance().SinkOnShutDown(sessionId, ShutdownReason::SHUTDOWN_REASON_LOCAL);
509     ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
510     EXPECT_EQ(DCAMERA_OK, ret);
511 }
512 
513 /**
514  * @tc.name: dcamera_softbus_adapter_test_017
515  * @tc.desc: Verify the OnSinkStreamReceived function.
516  * @tc.type: FUNC
517  * @tc.require:
518  */
519 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_017, TestSize.Level1)
520 {
521     std::string sessionName = "sourcetest013";
522     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
523     std::string mySessName = "sourcetest013";
524     std::string peerSessName = "sinktest012";
525     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_CTRL;
526     std::string peerDevId = TEST_DEVICE_ID;
527     std::string myDevId = "abcde";
528     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
529         sessionMode, role);
530     int32_t sessionId = 2;
531     PeerSocketInfo info = {
532         .name = const_cast<char*>(peerSessName.c_str()),
533         .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
534         .networkId = const_cast<char*>(peerDevId.c_str()),
535         .dataType = TransDataType::DATA_TYPE_BYTES,
536     };
537     ret = DCameraSoftbusAdapter::GetInstance().SinkOnBind(sessionId, info);
538     std::string buff01 = "testbuffer01";
539     StreamData test01;
540     test01.buf = const_cast<char *>(buff01.c_str());
541     test01.bufLen = buff01.size();
542     StreamData test02;
543     std::string buff02 = "testbuffer01";
544     test02.buf = const_cast<char *>(buff02.c_str());
545     test02.bufLen = buff02.size();
546     StreamFrameInfo param01;
547     const StreamData *data = &test01;
548     const StreamData *ext = &test02;
549     const StreamFrameInfo *param = &param01;
550     DCameraSoftbusAdapter::GetInstance().SinkOnStream(sessionId, data, ext, param);
551     DCameraSoftbusAdapter::GetInstance().SinkOnShutDown(sessionId, ShutdownReason::SHUTDOWN_REASON_LOCAL);
552     ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
553     EXPECT_EQ(DCAMERA_OK, ret);
554 }
555 
556 /**
557  * @tc.name: dcamera_softbus_adapter_test_018
558  * @tc.desc: Verify the DCameraSoftbusSourceGetSession function.
559  * @tc.type: FUNC
560  * @tc.require:
561  */
562 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_018, TestSize.Level1)
563 {
564     std::string sessionName = "sourcetest013";
565     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
566     std::string mySessName = "sourcetest013";
567     std::string peerSessName = "sinktest012";
568     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_CTRL;
569     std::string peerDevId = TEST_DEVICE_ID;
570     std::string myDevId = "abcde";
571     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
572         sessionMode, role);
573     int32_t sessionId = 2;
574     std::shared_ptr<DCameraSoftbusSession> session = std::make_shared<DCameraSoftbusSession>();
575     PeerSocketInfo info = {
576         .name = const_cast<char*>(peerSessName.c_str()),
577         .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
578         .networkId = const_cast<char*>(peerDevId.c_str()),
579         .dataType = TransDataType::DATA_TYPE_BYTES,
580     };
581     ret = DCameraSoftbusAdapter::GetInstance().SourceOnBind(sessionId, info);
582     ret = DCameraSoftbusAdapter::GetInstance().DCameraSoftbusSourceGetSession(sessionId, session);
583 
584     DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
585     EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
586 }
587 
588 /**
589  * @tc.name: dcamera_softbus_adapter_test_019
590  * @tc.desc: Verify the DCameraSoftbusSinkGetSession function.
591  * @tc.type: FUNC
592  * @tc.require:
593  */
594 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_019, TestSize.Level1)
595 {
596     std::string sessionName = "sourcetest013";
597     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
598     std::string mySessName = "sourcetest013";
599     std::string peerSessName = "sinktest012";
600     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_CTRL;
601     std::string peerDevId = TEST_DEVICE_ID;
602     std::string myDevId = "abcde";
603     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
604         sessionMode, role);
605     int32_t sessionId = 2;
606     PeerSocketInfo info = {
607         .name = const_cast<char*>(peerSessName.c_str()),
608         .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
609         .networkId = const_cast<char*>(peerDevId.c_str()),
610         .dataType = TransDataType::DATA_TYPE_BYTES,
611     };
612     std::shared_ptr<DCameraSoftbusSession> session = std::make_shared<DCameraSoftbusSession>();
613     ret = DCameraSoftbusAdapter::GetInstance().SinkOnBind(sessionId, info);
614     ret = DCameraSoftbusAdapter::GetInstance().DCameraSoftbusSinkGetSession(sessionId, session);
615 
616     DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
617     EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
618 }
619 
620 /**
621  * @tc.name: dcamera_softbus_adapter_test_020
622  * @tc.desc: Verify the DCameraSoftbusGetSessionById function.
623  * @tc.type: FUNC
624  * @tc.require:
625  */
626 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_020, TestSize.Level1)
627 {
628     std::string sessionName = "sourcetest013";
629     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
630     std::string mySessName = "sourcetest013";
631     std::string peerSessName = "sinktest012";
632     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_CTRL;
633     std::string peerDevId = TEST_DEVICE_ID;
634     std::string myDevId = "abcde";
635     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
636         sessionMode, role);
637     int32_t sessionId = 2;
638     PeerSocketInfo info = {
639         .name = const_cast<char*>(peerSessName.c_str()),
640         .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
641         .networkId = const_cast<char*>(peerDevId.c_str()),
642         .dataType = TransDataType::DATA_TYPE_BYTES,
643     };
644     std::shared_ptr<DCameraSoftbusSession> session = std::make_shared<DCameraSoftbusSession>();
645     ret = DCameraSoftbusAdapter::GetInstance().SinkOnBind(sessionId, info);
646     ret = DCameraSoftbusAdapter::GetInstance().DCameraSoftbusGetSessionById(sessionId, session);
647 
648     DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
649     EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
650 }
651 
652 /**
653  * @tc.name: dcamera_softbus_adapter_test_023
654  * @tc.desc: Verify the DCameraSoftbusGetSessionById function.
655  * @tc.type: FUNC
656  * @tc.require:
657  */
658 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_023, TestSize.Level1)
659 {
660     std::string sessionName = "sourcetest013";
661     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
662     std::string mySessName = "sourcetest013";
663     std::string peerSessName = "sinktest012";
664     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_CTRL;
665     std::string peerDevId = TEST_DEVICE_ID;
666     std::string myDevId = "abcde";
667     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
668         sessionMode, role);
669     int32_t sessionId = -1;
670     PeerSocketInfo info = {
671         .name = const_cast<char*>(peerSessName.c_str()),
672         .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
673         .networkId = const_cast<char*>(peerDevId.c_str()),
674         .dataType = TransDataType::DATA_TYPE_BYTES,
675     };
676     std::shared_ptr<DCameraSoftbusSession> session = std::make_shared<DCameraSoftbusSession>();
677     ret = DCameraSoftbusAdapter::GetInstance().SinkOnBind(sessionId, info);
678     ret = DCameraSoftbusAdapter::GetInstance().DCameraSoftbusGetSessionById(sessionId, session);
679 
680     DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
681     EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
682 }
683 
684 /**
685  * @tc.name: dcamera_softbus_adapter_test_027
686  * @tc.desc: Verify the DCameraSoftbusSourceGetSession function.
687  * @tc.type: FUNC
688  * @tc.require:
689  */
690 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_027, TestSize.Level1)
691 {
692     std::string sessionName = "sourcetest027";
693     DCAMERA_CHANNEL_ROLE role = DCAMERA_CHANNLE_ROLE_SOURCE;
694     std::string mySessName = "sourcetest027";
695     std::string peerSessName = "sinktest0027";
696     DCameraSessionMode sessionMode = DCameraSessionMode::DCAMERA_SESSION_MODE_CTRL;
697     std::string peerDevId = TEST_DEVICE_ID;
698     std::string myDevId = "abcde";
699     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
700         sessionMode, role);
701     int32_t sessionId = 27;
702     std::shared_ptr<DCameraSoftbusSession> session = std::make_shared<DCameraSoftbusSession>();
703     PeerSocketInfo info = {
704         .name = const_cast<char*>(peerSessName.c_str()),
705         .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
706         .networkId = const_cast<char*>(peerDevId.c_str()),
707         .dataType = TransDataType::DATA_TYPE_BYTES,
708     };
709     ret = DCameraSoftbusAdapter::GetInstance().SourceOnBind(sessionId, info);
710     ret = DCameraSoftbusAdapter::GetInstance().DCameraSoftbusSourceGetSession(sessionId, session);
711     EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
712     mySessName = "sourcetest0027";
713     ret = DCameraSoftbusAdapter::GetInstance().DCameraSoftbusSourceGetSession(sessionId, session);
714     EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
715     sessionId = 2;
716     DCameraSoftbusAdapter::GetInstance().sourceSessions_.clear();
717     DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
718     EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
719 }
720 
721 /**
722  * @tc.name: dcamera_softbus_adapter_test_028
723  * @tc.desc: Verify the OnSourceBytesReceived function.
724  * @tc.type: FUNC
725  * @tc.require:
726  */
727 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_028, TestSize.Level1)
728 {
729     int32_t sessionId = 2;
730     const void *data = "testdata";
731     uint32_t dataLen = 0;
732     std::string sessionName = "sourcetest028";
733     DCameraSoftbusAdapter::GetInstance().SourceOnBytes(sessionId, data, dataLen);
734     dataLen = DCAMERA_MAX_RECV_DATA_LEN + 1;
735     DCameraSoftbusAdapter::GetInstance().SourceOnBytes(sessionId, data, dataLen);
736     dataLen = 8;
737     data = nullptr;
738     DCameraSoftbusAdapter::GetInstance().SourceOnBytes(sessionId, data, dataLen);
739     int32_t ret = DCameraSoftbusAdapter::GetInstance().CloseSoftbusSession(sessionId);
740     EXPECT_EQ(DCAMERA_OK, ret);
741 }
742 
743 /**
744  * @tc.name: dcamera_softbus_adapter_test_029
745  * @tc.desc: Verify the OnSinkBytesReceived function.
746  * @tc.type: FUNC
747  * @tc.require:
748  */
749 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_029, TestSize.Level1)
750 {
751     int32_t sessionId = 2;
752     const void *data = "testdata";
753     uint32_t dataLen = 0;
754     std::string sessionName = "sourcetest029";
755     DCameraSoftbusAdapter::GetInstance().SinkOnBytes(sessionId, data, dataLen);
756     dataLen = DCAMERA_MAX_RECV_DATA_LEN + 1;
757     DCameraSoftbusAdapter::GetInstance().SinkOnBytes(sessionId, data, dataLen);
758     data = nullptr;
759     dataLen = 8;
760     DCameraSoftbusAdapter::GetInstance().SinkOnBytes(sessionId, data, dataLen);
761     int32_t ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
762     EXPECT_EQ(DCAMERA_OK, ret);
763 }
764 
765 /**
766  * @tc.name: dcamera_softbus_adapter_test_030
767  * @tc.desc: Verify the OnSinkBytesReceived function.
768  * @tc.type: FUNC
769  * @tc.require:
770  */
771 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_030, TestSize.Level1)
772 {
773     std::string sessionName = "sourcetest030";
774     int32_t sessionId = 2;
775     std::string buff01 = "testbuffer030";
776     StreamData test02;
777     std::string buff02 = "testbuffer030";
778     test02.buf = const_cast<char *>(buff02.c_str());
779     test02.bufLen = buff02.size();
780     StreamFrameInfo param01;
781     StreamData *data = nullptr;
782     StreamData *ext = &test02;
783     StreamFrameInfo *param = &param01;
784     DCameraSoftbusAdapter::GetInstance().SinkOnStream(sessionId, data, ext, param);
785     data = &test02;
786     data->bufLen = 0;
787     DCameraSoftbusAdapter::GetInstance().SinkOnStream(sessionId, data, ext, param);
788     data->bufLen = DCAMERA_MAX_RECV_DATA_LEN + 1;
789     DCameraSoftbusAdapter::GetInstance().SinkOnStream(sessionId, data, ext, param);
790     int32_t ret = DCameraSoftbusAdapter::GetInstance().DestroySoftbusSessionServer(sessionName);
791     EXPECT_EQ(DCAMERA_OK, ret);
792 }
793 
794 /**
795  * @tc.name: dcamera_softbus_adapter_test_032
796  * @tc.desc: Verify the CreateSoftbusSessionServer function.
797  * @tc.type: FUNC
798  * @tc.require:
799  */
800 HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_032, TestSize.Level1)
801 {
802     size_t capacity = 1;
803     std::shared_ptr<DataBuffer> dataBuffer = std::make_shared<DataBuffer>(capacity);
804     std::string buff01 = R"({
805         "type": 0,
806         "index": 1,
807         "pts": 1,
808         "encodeT": 1,
809         "sendT": 1,
810         "ver": "test",
811     })";
812     StreamData test01;
813     test01.buf = const_cast<char *>(buff01.c_str());
814     test01.bufLen = buff01.size();
815     StreamData *data = &test01;
816     int32_t ret = DCameraSoftbusAdapter::GetInstance().HandleSourceStreamExt(dataBuffer, data);
817     EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
818 
819     test01.bufLen = 0;
820     ret = DCameraSoftbusAdapter::GetInstance().HandleSourceStreamExt(dataBuffer, data);
821     EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
822 
823     test01.bufLen = DCAMERA_MAX_RECV_EXT_LEN + 1;
824     ret = DCameraSoftbusAdapter::GetInstance().HandleSourceStreamExt(dataBuffer, data);
825     EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
826 }
827 }
828 }