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
16 #include "softbus_transport_test.h"
17 #include "test_log.h"
18 #include "dtbschedmgr_log.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace DistributedSchedule {
25 namespace {
26 constexpr size_t SIZE_1 = 1;
27 constexpr size_t SIZE_2 = 2;
28 constexpr uint16_t SIZE_4 = 4;
29 constexpr uint32_t SIZE_6 = 6;
30 constexpr size_t OFFSET_1 = 1;
31 constexpr size_t OFFSET_2 = 2;
32 constexpr int32_t COUNT = 2;
33 constexpr int32_t SESSIONID = 0;
34 constexpr uint32_t SEQ_1 = 3;
35 constexpr uint32_t SEQ_2 = 4;
36 constexpr uint32_t TOTALLEN_1 = 5;
37 constexpr uint32_t TOTALLEN_2 = 8;
38 const std::string MYDEVIDEID = "myDeviceId";
39 const std::string PEERDEVICEID = "peerDeviceId";
40 const std::string SESSIONNAME = "sessionName";
41 constexpr uint32_t SHIFT_8 = 8;
42 constexpr uint16_t UINT16_SHIFT_MASK_TEST = 0x00ff;
43 }
44
45 // DSchedDataBufferTest
SetUpTestCase()46 void DSchedDataBufferTest::SetUpTestCase()
47 {
48 DTEST_LOG << "DSchedDataBufferTest::SetUpTestCase" << std::endl;
49 }
50
TearDownTestCase()51 void DSchedDataBufferTest::TearDownTestCase()
52 {
53 DTEST_LOG << "DSchedDataBufferTest::TearDownTestCase" << std::endl;
54 }
55
TearDown()56 void DSchedDataBufferTest::TearDown()
57 {
58 dataBufferTest_ = nullptr;
59 DTEST_LOG << "DSchedDataBufferTest::TearDown" << std::endl;
60 }
61
SetUp()62 void DSchedDataBufferTest::SetUp()
63 {
64 dataBufferTest_ = std::make_shared<DSchedDataBuffer>(SIZE_2);
65 DTEST_LOG << "DSchedDataBufferTest::SetUp" << std::endl;
66 }
67
68 //DSchedSoftbusSessionTest
SetUpTestCase()69 void DSchedSoftbusSessionTest::SetUpTestCase()
70 {
71 DTEST_LOG << "DSchedSoftbusSessionTest::SetUpTestCase" << std::endl;
72 }
73
TearDownTestCase()74 void DSchedSoftbusSessionTest::TearDownTestCase()
75 {
76 DTEST_LOG << "DSchedSoftbusSessionTest::TearDownTestCase" << std::endl;
77 }
78
TearDown()79 void DSchedSoftbusSessionTest::TearDown()
80 {
81 DTEST_LOG << "DSchedSoftbusSessionTest::TearDown" << std::endl;
82 }
83
SetUp()84 void DSchedSoftbusSessionTest::SetUp()
85 {
86 DTEST_LOG << "DSchedSoftbusSessionTest::SetUp" << std::endl;
87 }
88
89 //DSchedTransportSoftbusAdapterTest
SetUpTestCase()90 void DSchedTransportSoftbusAdapterTest::SetUpTestCase()
91 {
92 DTEST_LOG << "DSchedTransportSoftbusAdapterTest::SetUpTestCase" << std::endl;
93 }
94
TearDownTestCase()95 void DSchedTransportSoftbusAdapterTest::TearDownTestCase()
96 {
97 DTEST_LOG << "DSchedTransportSoftbusAdapterTest::TearDownTestCase" << std::endl;
98 }
99
TearDown()100 void DSchedTransportSoftbusAdapterTest::TearDown()
101 {
102 DTEST_LOG << "DSchedTransportSoftbusAdapterTest::TearDown" << std::endl;
103 }
104
SetUp()105 void DSchedTransportSoftbusAdapterTest::SetUp()
106 {
107 DTEST_LOG << "DSchedTransportSoftbusAdapterTest::SetUp" << std::endl;
108 }
109
110 /**
111 * @tc.name: Size_001
112 * @tc.desc: call Size
113 * @tc.type: FUNC
114 */
115 HWTEST_F(DSchedDataBufferTest, Size_001, TestSize.Level3)
116 {
117 DTEST_LOG << "DSchedDataBufferTest Size_001 begin" << std::endl;
118 ASSERT_NE(dataBufferTest_, nullptr);
119 size_t ret = dataBufferTest_->Size();
120 EXPECT_EQ(ret, SIZE_2);
121 DTEST_LOG << "DSchedDataBufferTest Size_001 end" << std::endl;
122 }
123
124 /**
125 * @tc.name: Offset_001
126 * @tc.desc: call Offset
127 * @tc.type: FUNC
128 */
129 HWTEST_F(DSchedDataBufferTest, Offset_001, TestSize.Level3)
130 {
131 DTEST_LOG << "DSchedDataBufferTest Offset_001 begin" << std::endl;
132 ASSERT_NE(dataBufferTest_, nullptr);
133 dataBufferTest_->rangeOffset_ = SIZE_2;
134 size_t ret = dataBufferTest_->Offset();
135 EXPECT_EQ(ret, SIZE_2);
136 DTEST_LOG << "DSchedDataBufferTest Offset_001 end" << std::endl;
137 }
138
139 /**
140 * @tc.name: Capacity_001
141 * @tc.desc: call Capacity
142 * @tc.type: FUNC
143 */
144 HWTEST_F(DSchedDataBufferTest, Capacity_001, TestSize.Level3)
145 {
146 DTEST_LOG << "DSchedDataBufferTest Capacity_001 begin" << std::endl;
147 ASSERT_NE(dataBufferTest_, nullptr);
148 size_t ret = dataBufferTest_->Capacity();
149 EXPECT_EQ(ret, SIZE_2);
150 DTEST_LOG << "DSchedDataBufferTest Capacity_001 end" << std::endl;
151 }
152
153 /**
154 * @tc.name: Data_001
155 * @tc.desc: call Data
156 * @tc.type: FUNC
157 */
158 HWTEST_F(DSchedDataBufferTest, Data_001, TestSize.Level3)
159 {
160 DTEST_LOG << "DSchedDataBufferTest Data_001 begin" << std::endl;
161 ASSERT_NE(dataBufferTest_, nullptr);
162 uint8_t *ret = dataBufferTest_->Data();
163 EXPECT_NE(ret, nullptr);
164 DTEST_LOG << "DSchedDataBufferTest Data_001 end" << std::endl;
165 }
166
167 /**
168 * @tc.name: Data_002
169 * @tc.desc: call Data
170 * @tc.type: FUNC
171 */
172 HWTEST_F(DSchedDataBufferTest, Data_002, TestSize.Level3)
173 {
174 DTEST_LOG << "DSchedDataBufferTest Data_002 begin" << std::endl;
175 ASSERT_NE(dataBufferTest_, nullptr);
176 dataBufferTest_->data_ = nullptr;
177 uint8_t *ret = dataBufferTest_->Data();
178 EXPECT_EQ(ret, nullptr);
179 DTEST_LOG << "DSchedDataBufferTest Data_002 end" << std::endl;
180 }
181
182 /**
183 * @tc.name: SetRange_001
184 * @tc.desc: call SetRange
185 * @tc.type: FUNC
186 */
187 HWTEST_F(DSchedDataBufferTest, SetRange_001, TestSize.Level3)
188 {
189 DTEST_LOG << "DSchedDataBufferTest SetRange_001 begin" << std::endl;
190 ASSERT_NE(dataBufferTest_, nullptr);
191 int32_t ret = dataBufferTest_->SetRange(OFFSET_2, SIZE_1);
192 EXPECT_EQ(ret, -1);
193 DTEST_LOG << "DSchedDataBufferTest SetRange_001 end" << std::endl;
194 }
195
196 /**
197 * @tc.name: SetRange_002
198 * @tc.desc: call SetRange
199 * @tc.type: FUNC
200 */
201 HWTEST_F(DSchedDataBufferTest, SetRange_002, TestSize.Level3)
202 {
203 DTEST_LOG << "DSchedDataBufferTest SetRange_002 begin" << std::endl;
204 ASSERT_NE(dataBufferTest_, nullptr);
205 int32_t ret = dataBufferTest_->SetRange(OFFSET_1, SIZE_2);
206 EXPECT_EQ(ret, -1);
207 DTEST_LOG << "DSchedDataBufferTest SetRange_002 end" << std::endl;
208 }
209
210 /**
211 * @tc.name: OnDisconnect_001
212 * @tc.desc: call OnDisconnect
213 * @tc.type: FUNC
214 */
215 HWTEST_F(DSchedSoftbusSessionTest, OnDisconnect_001, TestSize.Level3)
216 {
217 DTEST_LOG << "DSchedSoftbusSessionTest OnDisconnect_001 begin" << std::endl;
218 softbusSessionTest_ = std::make_shared<DSchedSoftbusSession>();
219 ASSERT_NE(softbusSessionTest_, nullptr);
220 softbusSessionTest_->OnConnect();
221
222 softbusSessionTest_->refCount_ = 0;
223 bool ret = softbusSessionTest_->OnDisconnect();
224 EXPECT_EQ(ret, true);
225
226 softbusSessionTest_->refCount_ = COUNT;
227 ret = softbusSessionTest_->OnDisconnect();
228 EXPECT_EQ(ret, false);
229 softbusSessionTest_ = nullptr;
230 DTEST_LOG << "DSchedSoftbusSessionTest OnDisconnect_001 end" << std::endl;
231 }
232
233 /**
234 * @tc.name: OnBytesReceived_001
235 * @tc.desc: call OnBytesReceived
236 * @tc.type: FUNC
237 */
238 HWTEST_F(DSchedSoftbusSessionTest, OnBytesReceived_001, TestSize.Level3)
239 {
240 DTEST_LOG << "DSchedSoftbusSessionTest OnBytesReceived_001 begin" << std::endl;
241 softbusSessionTest_ = std::make_shared<DSchedSoftbusSession>();
242 std::shared_ptr<DSchedDataBuffer> buffer = std::make_shared<DSchedDataBuffer>(SIZE_1);
243 ASSERT_NE(softbusSessionTest_, nullptr);
244 ASSERT_NE(buffer, nullptr);
245 int32_t ret = softbusSessionTest_->OnBytesReceived(buffer);
246 EXPECT_EQ(ret, ERR_OK);
247 softbusSessionTest_ = nullptr;
248 DTEST_LOG << "DSchedSoftbusSessionTest OnBytesReceived_001 end" << std::endl;
249 }
250
251 /**
252 * @tc.name: SendData_001
253 * @tc.desc: call SendData
254 * @tc.type: FUNC
255 */
256 HWTEST_F(DSchedSoftbusSessionTest, SendData_001, TestSize.Level3)
257 {
258 DTEST_LOG << "DSchedSoftbusSessionTest SendData_001 begin" << std::endl;
259 softbusSessionTest_ = std::make_shared<DSchedSoftbusSession>();
260 std::shared_ptr<DSchedDataBuffer> buffer = std::make_shared<DSchedDataBuffer>(SIZE_1);
261 ASSERT_NE(softbusSessionTest_, nullptr);
262 ASSERT_NE(buffer, nullptr);
263 int32_t dataType = COUNT;
264 int32_t ret = softbusSessionTest_->SendData(buffer, dataType);
265 EXPECT_EQ(ret, ERR_OK);
266 softbusSessionTest_ = nullptr;
267 DTEST_LOG << "DSchedSoftbusSessionTest SendData_001 end" << std::endl;
268 }
269
270 /**
271 * @tc.name: GetPeerDeviceId_001
272 * @tc.desc: call GetPeerDeviceId
273 * @tc.type: FUNC
274 */
275 HWTEST_F(DSchedSoftbusSessionTest, GetPeerDeviceId_001, TestSize.Level3)
276 {
277 DTEST_LOG << "DSchedSoftbusSessionTest GetPeerDeviceId_001 begin" << std::endl;
278 SessionInfo info = {0, MYDEVIDEID, PEERDEVICEID, SESSIONNAME, false};
279 softbusSessionTest_ = std::make_shared<DSchedSoftbusSession>(info);
280 ASSERT_NE(softbusSessionTest_, nullptr);
281 std::string str = softbusSessionTest_->GetPeerDeviceId();
282 EXPECT_EQ(str, PEERDEVICEID);
283 softbusSessionTest_ = nullptr;
284 DTEST_LOG << "DSchedSoftbusSessionTest GetPeerDeviceId_001 end" << std::endl;
285 }
286
287 /**
288 * @tc.name: CheckUnPackBuffer_001
289 * @tc.desc: call CheckUnPackBuffer
290 * @tc.type: FUNC
291 */
292 HWTEST_F(DSchedSoftbusSessionTest, CheckUnPackBuffer_001, TestSize.Level3)
293 {
294 DTEST_LOG << "DSchedSoftbusSessionTest CheckUnPackBuffer_001 begin" << std::endl;
295 SessionInfo info = {0, MYDEVIDEID, PEERDEVICEID, SESSIONNAME, false};
296 DSchedSoftbusSession::SessionDataHeader headerPara;
297 softbusSessionTest_ = std::make_shared<DSchedSoftbusSession>(info);
298 ASSERT_NE(softbusSessionTest_, nullptr);
299 softbusSessionTest_->isWaiting_ = false;
300 int32_t ret = softbusSessionTest_->CheckUnPackBuffer(headerPara);
301 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
302
303 softbusSessionTest_->isWaiting_ = true;
304 softbusSessionTest_->nowSeq_ = SEQ_1;
305 ret = softbusSessionTest_->CheckUnPackBuffer(headerPara);
306 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
307 softbusSessionTest_ = nullptr;
308 DTEST_LOG << "DSchedSoftbusSessionTest CheckUnPackBuffer_001 end" << std::endl;
309 }
310
311 /**
312 * @tc.name: CheckUnPackBuffer_002
313 * @tc.desc: call CheckUnPackBuffer
314 * @tc.type: FUNC
315 */
316 HWTEST_F(DSchedSoftbusSessionTest, CheckUnPackBuffer_002, TestSize.Level3)
317 {
318 DTEST_LOG << "DSchedSoftbusSessionTest CheckUnPackBuffer_002 begin" << std::endl;
319 SessionInfo info = {0, MYDEVIDEID, PEERDEVICEID, SESSIONNAME, false};
320 DSchedSoftbusSession::SessionDataHeader headerPara = {0, 0, 0, SEQ_1, 0, SEQ_2, TOTALLEN_1};
321 softbusSessionTest_ = std::make_shared<DSchedSoftbusSession>(info);
322 ASSERT_NE(softbusSessionTest_, nullptr);
323 softbusSessionTest_->nowSeq_ = SEQ_1;
324 softbusSessionTest_->nowSubSeq_ = SEQ_2;
325 softbusSessionTest_->isWaiting_ = true;
326 int32_t ret = softbusSessionTest_->CheckUnPackBuffer(headerPara);
327 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
328
329 softbusSessionTest_->nowSeq_ = SEQ_1;
330 softbusSessionTest_->nowSubSeq_ = SEQ_1;
331 softbusSessionTest_->isWaiting_ = true;
332 ret = softbusSessionTest_->CheckUnPackBuffer(headerPara);
333 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
334 softbusSessionTest_ = nullptr;
335 DTEST_LOG << "DSchedSoftbusSessionTest CheckUnPackBuffer_002 end" << std::endl;
336 }
337
338 /**
339 * @tc.name: CheckUnPackBuffer_003
340 * @tc.desc: call CheckUnPackBuffer
341 * @tc.type: FUNC
342 */
343 HWTEST_F(DSchedSoftbusSessionTest, CheckUnPackBuffer_003, TestSize.Level3)
344 {
345 DTEST_LOG << "DSchedSoftbusSessionTest CheckUnPackBuffer_003 begin" << std::endl;
346 SessionInfo info = {0, MYDEVIDEID, PEERDEVICEID, SESSIONNAME, false};
347 DSchedSoftbusSession::SessionDataHeader headerPara = {0, 0, 0, SEQ_1, 0, SEQ_2, TOTALLEN_1};
348 softbusSessionTest_ = std::make_shared<DSchedSoftbusSession>(info);
349 ASSERT_NE(softbusSessionTest_, nullptr);
350 softbusSessionTest_->nowSeq_ = SEQ_1;
351 softbusSessionTest_->nowSubSeq_ = SEQ_1;
352 softbusSessionTest_->totalLen_ = TOTALLEN_2;
353 softbusSessionTest_->offset_ = SEQ_1;
354 softbusSessionTest_->isWaiting_ = true;
355 int32_t ret = softbusSessionTest_->CheckUnPackBuffer(headerPara);
356 EXPECT_EQ(ret, ERR_OK);
357 softbusSessionTest_ = nullptr;
358 DTEST_LOG << "DSchedSoftbusSessionTest CheckUnPackBuffer_003 end" << std::endl;
359 }
360
361 /**
362 * @tc.name: UnPackSendData_001
363 * @tc.desc: call UnPackSendData
364 * @tc.type: FUNC
365 */
366 HWTEST_F(DSchedSoftbusSessionTest, UnPackSendData_001, TestSize.Level3)
367 {
368 DTEST_LOG << "DSchedSoftbusSessionTest UnPackSendData_001 begin" << std::endl;
369 int32_t dataType = 0;
370 softbusSessionTest_ = std::make_shared<DSchedSoftbusSession>();
371 ASSERT_NE(softbusSessionTest_, nullptr);
372 std::shared_ptr<DSchedDataBuffer> buffer = std::make_shared<DSchedDataBuffer>(SIZE_1);
373 int32_t ret = softbusSessionTest_->UnPackSendData(buffer, dataType);
374 EXPECT_NE(ret, ERR_OK);
375 softbusSessionTest_ = nullptr;
376 DTEST_LOG << "DSchedSoftbusSessionTest UnPackSendData_001 end" << std::endl;
377 }
378
379 /**
380 * @tc.name: UnPackStartEndData_001
381 * @tc.desc: call UnPackStartEndData
382 * @tc.type: FUNC
383 */
384 HWTEST_F(DSchedSoftbusSessionTest, UnPackStartEndData_001, TestSize.Level3)
385 {
386 DTEST_LOG << "DSchedSoftbusSessionTest UnPackStartEndData_001 begin" << std::endl;
387 int32_t dataType = 0;
388 softbusSessionTest_ = std::make_shared<DSchedSoftbusSession>();
389 ASSERT_NE(softbusSessionTest_, nullptr);
390 std::shared_ptr<DSchedDataBuffer> buffer = std::make_shared<DSchedDataBuffer>(SIZE_1);
391 int32_t ret = softbusSessionTest_->UnPackStartEndData(buffer, dataType);
392 EXPECT_NE(ret, ERR_OK);
393 softbusSessionTest_ = nullptr;
394 DTEST_LOG << "DSchedSoftbusSessionTest UnPackStartEndData_001 end" << std::endl;
395 }
396
397 /**
398 * @tc.name: GetFragDataHeader_001
399 * @tc.desc: call GetFragDataHeader
400 * @tc.type: FUNC
401 */
402 HWTEST_F(DSchedSoftbusSessionTest, GetFragDataHeader_001, TestSize.Level3)
403 {
404 DTEST_LOG << "DSchedSoftbusSessionTest GetFragDataHeader_001 begin" << std::endl;
405 int32_t dataType = 0;
406 softbusSessionTest_ = std::make_shared<DSchedSoftbusSession>();
407 ASSERT_NE(softbusSessionTest_, nullptr);
408
409 std::shared_ptr<DSchedDataBuffer> buffer =
410 std::make_shared<DSchedDataBuffer>(static_cast<size_t>(DSchedSoftbusSession::BINARY_HEADER_FRAG_LEN));
411
412 auto ptr = buffer->Data();
413 ASSERT_NE(ptr, nullptr);
414 uint32_t i = 0;
415 for (int32_t j = 0; j < SIZE_6; j++) {
416 ptr[i++] = DSchedSoftbusSession::TLV_TYPE_SEQ_NUM >> SHIFT_8;
417 ptr[i++] = DSchedSoftbusSession::TLV_TYPE_SEQ_NUM & UINT16_SHIFT_MASK_TEST;
418 ptr[i++] = SIZE_4 >> SHIFT_8;
419 ptr[i++] = SIZE_4 & UINT16_SHIFT_MASK_TEST;
420 ptr[i++] = 1;
421 ptr[i++] = 0;
422 ptr[i++] = 0;
423 ptr[i++] = 0;
424 }
425
426 DSchedSoftbusSession::SessionDataHeader headerPara;
427 int32_t ret = softbusSessionTest_->GetFragDataHeader(ptr, headerPara);
428 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
429
430 softbusSessionTest_ = nullptr;
431 DTEST_LOG << "DSchedSoftbusSessionTest GetFragDataHeader_001 end" << std::endl;
432 }
433
434 /**
435 * @tc.name: InitChannel_001
436 * @tc.desc: call InitChannel
437 * @tc.type: FUNC
438 */
439 HWTEST_F(DSchedTransportSoftbusAdapterTest, InitChannel_001, TestSize.Level3)
440 {
441 DTEST_LOG << "DSchedTransportSoftbusAdapterTest InitChannel_001 begin" << std::endl;
442 DSchedTransportSoftbusAdapter::GetInstance().serverSocket_ = COUNT;
443 int32_t ret = DSchedTransportSoftbusAdapter::GetInstance().InitChannel();
444 EXPECT_NE(ret, ERR_OK);
445 DTEST_LOG << "DSchedTransportSoftbusAdapterTest InitChannel_001 end" << std::endl;
446 }
447
448 /**
449 * @tc.name: OnBind_001
450 * @tc.desc: call OnBind with get local
451 * @tc.type: FUNC
452 */
453 HWTEST_F(DSchedTransportSoftbusAdapterTest, OnBind_001, TestSize.Level3)
454 {
455 DTEST_LOG << "DSchedTransportSoftbusAdapterTest OnBind_001 begin" << std::endl;
456 int32_t sessionId = 0;
457 DSchedTransportSoftbusAdapter::GetInstance().OnBind(sessionId, PEERDEVICEID);
458 EXPECT_EQ(sessionId, 0);
459 DTEST_LOG << "DSchedTransportSoftbusAdapterTest OnBind_001 end" << std::endl;
460 }
461
462 /**
463 * @tc.name: GetSessionIdByDeviceId_001
464 * @tc.desc: call GetSessionIdByDeviceId
465 * @tc.type: FUNC
466 */
467 HWTEST_F(DSchedTransportSoftbusAdapterTest, GetSessionIdByDeviceId_001, TestSize.Level3)
468 {
469 DTEST_LOG << "DSchedTransportSoftbusAdapterTest GetSessionIdByDeviceId_001 begin" << std::endl;
470 int32_t sessionId = 0;
471 std::shared_ptr<DSchedDataBuffer> dataBuffer = std::make_shared<DSchedDataBuffer>(SIZE_1);
472 ASSERT_NE(dataBuffer, nullptr);
473 uint32_t dataType = 0;
474 std::shared_ptr<IDataListener> listener = nullptr;
475 DSchedTransportSoftbusAdapter::GetInstance().OnDataReady(sessionId, dataBuffer, dataType);
476 DSchedTransportSoftbusAdapter::GetInstance().listeners_.clear();
477 DSchedTransportSoftbusAdapter::GetInstance().OnDataReady(sessionId, dataBuffer, dataType);
478
479 int32_t serviceType = 0;
480 DSchedTransportSoftbusAdapter::GetInstance().RegisterListener(serviceType, listener);
481 DSchedTransportSoftbusAdapter::GetInstance().UnregisterListener(serviceType, listener);
482
483 bool ret = DSchedTransportSoftbusAdapter::GetInstance().GetSessionIdByDeviceId(PEERDEVICEID, sessionId);
484 EXPECT_EQ(ret, false);
485 DTEST_LOG << "DSchedTransportSoftbusAdapterTest GetSessionIdByDeviceId_001 end" << std::endl;
486 }
487
488 /**
489 * @tc.name: ReleaseChannel_001
490 * @tc.desc: call ReleaseChannel
491 * @tc.type: FUNC
492 */
493 HWTEST_F(DSchedTransportSoftbusAdapterTest, ReleaseChannel_001, TestSize.Level3)
494 {
495 DTEST_LOG << "DSchedTransportSoftbusAdapterTest ReleaseChannel_001 begin" << std::endl;
496 int32_t sessionId = 0;
497 bool isSelfcalled = false;
498 DSchedTransportSoftbusAdapter::GetInstance().OnShutdown(sessionId, isSelfcalled);
499 DSchedTransportSoftbusAdapter::GetInstance().NotifyListenersSessionShutdown(sessionId, isSelfcalled);
500 DSchedTransportSoftbusAdapter::GetInstance().OnBytes(sessionId, nullptr, 0);
501 int32_t ret = DSchedTransportSoftbusAdapter::GetInstance().ReleaseChannel();
502 EXPECT_EQ(ret, -ERR_OK);
503 DTEST_LOG << "DSchedTransportSoftbusAdapterTest ReleaseChannel_001 end" << std::endl;
504 }
505 }
506 }