1 /*
2 * Copyright (c) 2021 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 "net_trans_common.h"
19 #include "wifi_utils.h"
20
21 static int g_waitFlag = WAIT_DEF_VALUE;
FileSessionOpened(int sessionId,int result)22 static int FileSessionOpened(int sessionId, int result)
23 {
24 LOG("[cb][file]open session sid[%d],rst[%d]", sessionId, result);
25 if (result == SOFTBUS_OK) {
26 g_waitFlag = WAIT_SUCCESS_VALUE;
27 } else {
28 g_waitFlag = WAIT_FAIL_VALUE;
29 }
30 return SOFTBUS_OK;
31 }
32
FileSessionClosed(int sessionId)33 static void FileSessionClosed(int sessionId)
34 {
35 LOG("[cb][file]close session sid[%d]", sessionId);
36 }
37
FileBytesReceived(int sessionId,const void * data,unsigned int dataLen)38 static void FileBytesReceived(int sessionId, const void* data, unsigned int dataLen)
39 {
40 LOG("[cb][file]ByteRec sid:%d, data len:%d", sessionId, dataLen);
41 if (data == NULL) {
42 LOG("[cb][file]ByteRec invalid data=null sid[%d]", sessionId);
43 g_waitFlag = WAIT_FAIL_VALUE;
44 } else {
45 g_waitFlag = WAIT_SUCCESS_VALUE;
46 }
47 }
48
FileMessageReceived(int sessionId,const void * data,unsigned int dataLen)49 static void FileMessageReceived(int sessionId, const void* data, unsigned int dataLen)
50 {
51 LOG("[cb][file]MessageRec sid:%d, data len:%d", sessionId, dataLen);
52 if (data == NULL) {
53 LOG("[cb][file]MessageRec invalid data=null sid[%d]", sessionId);
54 g_waitFlag = WAIT_FAIL_VALUE;
55 } else {
56 g_waitFlag = WAIT_SUCCESS_VALUE;
57 }
58 }
59
60 static SessionAttribute g_fileSessionAttr = {
61 .dataType = TYPE_FILE,
62 };
63
64 static ISessionListener g_fileSessionListener = {
65 .OnSessionOpened = FileSessionOpened,
66 .OnSessionClosed = FileSessionClosed,
67 .OnBytesReceived = FileBytesReceived,
68 .OnMessageReceived = FileMessageReceived,
69 };
70
71 using namespace testing::ext;
72
73 class TransSessionFuncTest : public testing::Test {
74 public:
75 // 测试套前置和后置操作
76 static void SetUpTestCase();
77 static void TearDownTestCase();
78
79 // 测试用例前置和后置操作
80 void SetUp();
81 void TearDown();
82 };
83
SetUp()84 void TransSessionFuncTest::SetUp() {}
85
TearDown()86 void TransSessionFuncTest::TearDown() {}
87
SetUpTestCase()88 void TransSessionFuncTest::SetUpTestCase()
89 {
90 LOG("SetUp begin");
91 AddPermission();
92 sleep(1);
93 system("pidof accesstoken_ser | xargs kill -9");
94 sleep(1);
95 TestSetUp();
96
97 int ret = RegisterDeviceStateDefCallback();
98 EXPECT_EQ(SOFTBUS_OK, ret) << "call reg node state callback fail";
99
100 ret = CheckRemoteDeviceIsNull(BOOL_TRUE);
101 ASSERT_EQ(SOFTBUS_OK, ret) << "get node fail,please check network";
102
103 system(" truncate -s 8M /data/8M.tar");
104
105 LOG("SetUp end");
106 }
107
TearDownTestCase()108 void TransSessionFuncTest::TearDownTestCase()
109 {
110 int ret = UnRegisterDeviceStateDefCallback();
111 EXPECT_EQ(SOFTBUS_OK, ret) << "call unReg node state callback fail";
112
113 TestTearDown();
114 }
115
116 /**
117 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Func_0100
118 * @tc.name : one Client creates SessionServer + 1, Max succeeds, 1 fails
119 * @tc.desc : Test session management
120 * @tc.type : FUNC
121 * @tc.size : MediumTest
122 */
123 HWTEST_F(TransSessionFuncTest, SUB_Softbus_Trans_Comp_OpenSession_Func_0100, TestSize.Level3)
124 {
125 int ret;
126 char sessionNames[][SESSION_NAME_SIZE_MAX] = { "com.communication.demo1.1", "com.communication.demo1.2",
127 "com.communication.demo1.3", "com.communication.demo1.4", "com.communication.demo1.5",
128 "com.communication.demo1.6", "com.communication.demo1.7", "com.communication.demo1.8" };
129 for (int i = 0; i < MAX_SESSION_SERVER_NUM_CLIENT; i++) {
130 ret = CreateSessionServer(DEF_PKG_NAME, sessionNames[i], GetSessionListenser4Data());
131 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS fail,i=" << i;
132 }
133 string sessionName = "max+1";
134 ret = CreateSessionServer(DEF_PKG_NAME, sessionName.c_str(), GetSessionListenser4Data());
135 printf("CreateSS max+1, ret:%d \n", ret);
136 EXPECT_NE(SOFTBUS_OK, ret) << "CreateSS max+1 success, expect fail";
137
138 for (int i = 0; i < MAX_SESSION_SERVER_NUM_CLIENT; i++) {
139 ret = RemoveSessionServer(DEF_PKG_NAME, sessionNames[i]);
140 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS fail,i=" << i;
141 }
142 ret = RemoveSessionServer(DEF_PKG_NAME, sessionName.c_str());
143 printf("RemoveSS max+1, ret:%d \n", ret);
144 EXPECT_NE(SOFTBUS_OK, ret) << "RemoveSS max+1 success, expect fail";
145 }
146
147 /**
148 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Func_0200
149 * @tc.name : OpenSession + 1, Max succeeds, 1 fails
150 * @tc.desc : Test session management
151 * @tc.type : FUNC
152 * @tc.size : MediumTest
153 */
154 HWTEST_F(TransSessionFuncTest, SUB_Softbus_Trans_Comp_OpenSession_Func_0200, TestSize.Level3)
155 {
156 int ret;
157 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, GetSessionListenser4Data());
158 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS[data] fail";
159 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_CTL, GetSessionListenser4Ctl());
160 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS[ctrl] fail";
161
162 int count = MAX_SESSION_NUM / 2;
163 int sessionId4Data[count];
164 int sessionId4Ctrl[count];
165 char groupId[][4] = { "g1", "g2", "g3", "g4", "g5", "g6", "g7", "g8" };
166 ret = OpenSessionBatch4Data(groupId, sessionId4Data, count);
167 EXPECT_EQ(SOFTBUS_OK, ret) << "OpenSessionWithDiffGroupId4Data fail";
168 ret = OpenSessionBatch4Ctl(groupId, sessionId4Ctrl, count);
169 EXPECT_EQ(SOFTBUS_OK, ret) << "OpenSessionWithDiffGroupId4Ctl fail";
170
171 // open max+1, expect fail
172 int sessionId;
173 sessionId = OpenSession(SESSION_NAME_DATA, SESSION_NAME_DATA, GetNetworkId(), DEF_GROUP_ID, GetSessionAttr4Data());
174 EXPECT_FALSE(sessionId >= SESSION_ID_MIN) << "call OpenSession[data] success,sid=" << sessionId;
175
176 // close session
177 ret = CloseSessionBatch4Data(sessionId4Data, count);
178 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionBatch4Data fail";
179 ret = CloseSessionBatch4Ctl(sessionId4Ctrl, count);
180 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionBatch4Ctl fail";
181
182 // remove session server
183 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
184 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS[data] fail";
185 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_CTL);
186 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS[ctrl] fail";
187 }
188
189 /**
190 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Func_0300
191 * @tc.name : Obtain DevicedName based on Sessionid
192 * @tc.desc : Test session management
193 * @tc.type : FUNC
194 * @tc.size : MediumTest
195 */
196 HWTEST_F(TransSessionFuncTest, SUB_Softbus_Trans_Comp_OpenSession_Func_0300, TestSize.Level3)
197 {
198 int ret;
199 ret = CreateSsAndOpenSession4Data();
200 ASSERT_EQ(SOFTBUS_OK, ret) << "create Ss and openS[data] fail";
201
202 int sessionId = GetCurrentSessionId4Data();
203 char mySessionName[SESSION_NAME_SIZE_MAX] = { 0 };
204 ret = GetMySessionName(sessionId, mySessionName, SESSION_NAME_SIZE_MAX);
205 EXPECT_EQ(SOFTBUS_OK, ret) << "call GetMySessionName fail, sid:" << sessionId;
206 EXPECT_STREQ(SESSION_NAME_DATA, mySessionName) << "my session name cmp fail";
207
208 char peerSessionName[SESSION_NAME_SIZE_MAX] = { 0 };
209 ret = GetPeerSessionName(sessionId, peerSessionName, SESSION_NAME_SIZE_MAX);
210 EXPECT_EQ(SOFTBUS_OK, ret) << "call GetPeerSessionName fail";
211 EXPECT_STREQ(SESSION_NAME_DATA, peerSessionName) << "peer session name cmp fail";
212
213 ret = CloseSessionAndRemoveSs4Data();
214 EXPECT_EQ(SOFTBUS_OK, ret) << "close session and remove Ss fail";
215 }
216
217 /**
218 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Func_0400
219 * @tc.name : Obtain DevicedId based on Sessionid
220 * @tc.desc : Test session management
221 * @tc.type : FUNC
222 * @tc.size : MediumTest
223 */
224 HWTEST_F(TransSessionFuncTest, SUB_Softbus_Trans_Comp_OpenSession_Func_0400, TestSize.Level3)
225 {
226 int ret;
227 ret = CreateSsAndOpenSession4Ctl();
228 ASSERT_EQ(SOFTBUS_OK, ret) << "create Ss and openS[ctl] fail";
229
230 char deviceId[SESSION_NAME_SIZE_MAX] = { 0 };
231 ret = GetPeerDeviceId(GetCurrentSessionId4Ctl(), deviceId, SESSION_NAME_SIZE_MAX);
232 EXPECT_EQ(SOFTBUS_OK, ret) << "call GetPeerDeviceId fail";
233 EXPECT_STREQ(GetNetworkId(), deviceId) << "peer device id cmp fail";
234
235 ret = CloseSessionAndRemoveSs4Ctl();
236 EXPECT_EQ(SOFTBUS_OK, ret) << "close session and remove Ss fail";
237 }
238
239 /**
240 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Func_0500
241 * @tc.name : OpenSession Type is TYPE_BYTES sendfile fail
242 * @tc.desc : 【G-DISTRIBUTED-0205】禁止修改Openharmony分布式软总线设备间传输通道管理协议。
243 * @tc.type : FUNC
244 * @tc.size : MediumTest
245 */
246 HWTEST_F(TransSessionFuncTest, SUB_Softbus_Trans_Comp_OpenSession_Func_0500, TestSize.Level3)
247 {
248 int ret;
249 int sessionId;
250 int timeout = 10;
251
252 static const char* g_file[] = {
253 "/data/8M.tar",
254 };
255
256 static const char *recv_file[] = {
257 "/data/datatype_8M.tar",
258 };
259
260 ret = SetFileSendListener(DEF_PKG_NAME, SESSION_NAME_FILE, GetSendFileListener());
261 EXPECT_EQ(SOFTBUS_OK, ret) << "call SetFileSendListener fail";
262 ret = SetFileReceiveListener(DEF_PKG_NAME, SESSION_NAME_FILE, GetRecvFileListener(), RECV_FILE_PATH);
263 EXPECT_EQ(SOFTBUS_OK, ret) << "call SetFileSendListener fail";
264
265 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_FILE, &g_fileSessionListener);
266 EXPECT_EQ(SOFTBUS_OK, ret) << "call CreateSS[file] fail";
267
268 sessionId = OpenSession(SESSION_NAME_FILE, SESSION_NAME_FILE, GetNetworkId(), DEF_GROUP_ID, GetSessionAttr4Data());
269 if (sessionId < SESSION_ID_MIN)
270 {
271 LOG("call opensession[file] fail, ret sid:%d, netid:%s", sessionId, GetNetworkId());
272 }
273 ret = Wait4Session(timeout, SESSION_4DATA);
274 if (ret != SOFTBUS_OK)
275 {
276 LOG("call opensession[file] fail");
277 }
278
279 ret = SendFile(sessionId, g_file, recv_file, 1);
280 EXPECT_NE(SOFTBUS_OK, ret) << "sendfile succees";
281
282 CloseSession(sessionId);
283
284 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_FILE);
285 EXPECT_EQ(SOFTBUS_OK, ret) << "remove Ss fail";
286 }
287
288 /**
289 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Func_0600
290 * @tc.name : OpenSession Type is TYPE_MESSAGE sendfile fail
291 * @tc.desc : Test session management
292 * @tc.type : FUNC
293 * @tc.size : MediumTest
294 */
295 HWTEST_F(TransSessionFuncTest, SUB_Softbus_Trans_Comp_OpenSession_Func_0600, TestSize.Level3)
296 {
297 int ret;
298 int sessionId;
299 int timeout = 10;
300
301 static const char* g_file[] = {
302 "/data/8M.tar",
303 };
304
305 static const char *recv_file[] = {
306 "/data/messagetype_8M.tar",
307 };
308
309 ret = SetFileSendListener(DEF_PKG_NAME, SESSION_NAME_PROXY, GetSendFileListener());
310 EXPECT_EQ(SOFTBUS_OK, ret) << "call SetFileSendListener fail";
311 ret = SetFileReceiveListener(DEF_PKG_NAME, SESSION_NAME_PROXY, GetRecvFileListener(), RECV_FILE_PATH);
312 EXPECT_EQ(SOFTBUS_OK, ret) << "call SetFileSendListener fail";
313
314 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_PROXY, GetSessionListenser4Proxy());
315 EXPECT_EQ(SOFTBUS_OK, ret) << "call CreateSS[file] fail";
316
317 sessionId = OpenSession(SESSION_NAME_PROXY, SESSION_NAME_PROXY, GetNetworkId(), DEF_GROUP_ID, GetSessionAttr4Proxy());
318 if (sessionId < SESSION_ID_MIN)
319 {
320 LOG("call opensession[message] fail, ret sid:%d, netid:%s", sessionId, GetNetworkId());
321 }
322 ret = Wait4Session(timeout, SESSION_4PROXY);
323 if (ret != SOFTBUS_OK)
324 {
325 LOG("call opensession[message] fail");
326 }
327
328 ret = SendFile(sessionId, g_file, recv_file, 1);
329 EXPECT_NE(SOFTBUS_OK, ret) << "sendfile succees";
330
331 CloseSession(sessionId);
332
333 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_PROXY);
334 EXPECT_EQ(SOFTBUS_OK, ret) << "remove Ss fail";
335 }
336
337 /**
338 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Func_0700
339 * @tc.name : OpenSession Type is TYPE_STREAM sendfile fail
340 * @tc.desc : Test session management
341 * @tc.type : FUNC
342 * @tc.size : MediumTest
343 */
344 HWTEST_F(TransSessionFuncTest, SUB_Softbus_Trans_Comp_OpenSession_Func_0700, TestSize.Level3)
345 {
346 int ret;
347 int sessionId;
348 int timeout = 10;
349
350 static const char* g_file[] = {
351 "/data/8M.tar",
352 };
353
354 static const char *recv_file[] = {
355 "/data/streamtype_8M.tar",
356 };
357
358 ret = SetFileSendListener(DEF_PKG_NAME, SESSION_NAME_STREAM, GetSendFileListener());
359 EXPECT_EQ(SOFTBUS_OK, ret) << "call SetFileSendListener fail";
360 ret = SetFileReceiveListener(DEF_PKG_NAME, SESSION_NAME_STREAM, GetRecvFileListener(), RECV_FILE_PATH);
361 EXPECT_EQ(SOFTBUS_OK, ret) << "call SetFileSendListener fail";
362
363 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_STREAM, GetSessionListenser4Stream());
364 EXPECT_EQ(SOFTBUS_OK, ret) << "call CreateSS[file] fail";
365
366 SessionAttribute attr;
367 (void)memset_s(&attr, sizeof(attr), 0, sizeof(attr));
368 attr.dataType = TYPE_STREAM;
369 sessionId = OpenSession(SESSION_NAME_STREAM, SESSION_NAME_STREAM, GetNetworkId(), DEF_GROUP_ID, &attr);
370 if (sessionId < SESSION_ID_MIN)
371 {
372 LOG("call opensession[stream] fail, ret sid:%d, netid:%s", sessionId, GetNetworkId());
373 }
374 ret = Wait4Session(timeout, SESSION_4STREAM);
375 if (ret != SOFTBUS_OK)
376 {
377 LOG("call opensession[stream] fail");
378 }
379
380 ret = SendFile(sessionId, g_file, recv_file, 1);
381 EXPECT_NE(SOFTBUS_OK, ret) << "sendfile succees";
382
383 CloseSession(sessionId);
384
385 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_STREAM);
386 EXPECT_EQ(SOFTBUS_OK, ret) << "remove Ss fail";
387 }
388
389 /**
390 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Func_0800
391 * @tc.name : OpenSession Type is TYPE_BYTES sendstream fail
392 * @tc.desc : Test session management
393 * @tc.type : FUNC
394 * @tc.size : MediumTest
395 */
396 HWTEST_F(TransSessionFuncTest, SUB_Softbus_Trans_Comp_OpenSession_Func_0800, TestSize.Level3)
397 {
398 int ret;
399 int sessionId;
400 int timeout = 10;
401
402 string data = "send stream transmission test!!!!";
403 char *sendData = (char *)malloc(data.length() + 1);
404 EXPECT_NE(sendData, nullptr);
405 ret = strcpy_s(sendData, data.length() + 1, data.c_str());
406 EXPECT_EQ(ret, SOFTBUS_OK);
407 StreamData extStreamData {0};
408 StreamData streamData {
409 .buf = sendData,
410 .bufLen = data.length() + 1,
411 };
412 StreamFrameInfo frame = {0};
413
414 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_STREAM, &g_fileSessionListener);
415 EXPECT_EQ(SOFTBUS_OK, ret) << "call CreateSS[file] fail";
416
417 sessionId = OpenSession(SESSION_NAME_STREAM, SESSION_NAME_STREAM, GetNetworkId(), DEF_GROUP_ID, GetSessionAttr4Data());
418 if (sessionId < SESSION_ID_MIN)
419 {
420 LOG("call opensession[file] fail, ret sid:%d, netid:%s", sessionId, GetNetworkId());
421 }
422 ret = Wait4Session(timeout, SESSION_4DATA);
423 if (ret != SOFTBUS_OK)
424 {
425 LOG("call opensession[file] fail");
426 }
427
428 ret = SendStream(sessionId, &streamData, &extStreamData, &frame);
429 EXPECT_NE(SOFTBUS_OK, ret) << "sendstream succees";
430
431 CloseSession(sessionId);
432
433 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_FILE);
434 EXPECT_EQ(SOFTBUS_OK, ret) << "remove Ss fail";
435 }
436
437 /**
438 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Func_0900
439 * @tc.name : OpenSession Type is TYPE_MESSAGE sendstream fail
440 * @tc.desc : Test session management
441 * @tc.type : FUNC
442 * @tc.size : MediumTest
443 */
444 HWTEST_F(TransSessionFuncTest, SUB_Softbus_Trans_Comp_OpenSession_Func_0900, TestSize.Level3)
445 {
446 int ret;
447 int sessionId;
448 int timeout = 10;
449
450 string data = "send stream transmission test!!!!";
451 char *sendData = (char *)malloc(data.length() + 1);
452 EXPECT_NE(sendData, nullptr);
453 ret = strcpy_s(sendData, data.length() + 1, data.c_str());
454 EXPECT_EQ(ret, SOFTBUS_OK);
455 StreamData extStreamData {0};
456 StreamData streamData {
457 .buf = sendData,
458 .bufLen = data.length() + 1,
459 };
460 StreamFrameInfo frame = {0};
461
462 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_PROXY, GetSessionListenser4Proxy());
463 EXPECT_EQ(SOFTBUS_OK, ret) << "call CreateSS[file] fail";
464
465 sessionId = OpenSession(SESSION_NAME_PROXY, SESSION_NAME_PROXY, GetNetworkId(), DEF_GROUP_ID, GetSessionAttr4Proxy());
466 if (sessionId < SESSION_ID_MIN)
467 {
468 LOG("call opensession[message] fail, ret sid:%d, netid:%s", sessionId, GetNetworkId());
469 }
470 ret = Wait4Session(timeout, SESSION_4PROXY);
471 if (ret != SOFTBUS_OK)
472 {
473 LOG("call opensession[message] fail");
474 }
475
476 ret = SendStream(sessionId, &streamData, &extStreamData, &frame);
477 EXPECT_NE(SOFTBUS_OK, ret) << "sendstream succees";
478
479 CloseSession(sessionId);
480
481 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_PROXY);
482 EXPECT_EQ(SOFTBUS_OK, ret) << "remove Ss fail";
483 }
484
485 /**
486 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Func_1000
487 * @tc.name : OpenSession Type is TYPE_FILE sendstream fail
488 * @tc.desc : Test session management
489 * @tc.type : FUNC
490 * @tc.size : MediumTest
491 */
492 HWTEST_F(TransSessionFuncTest, SUB_Softbus_Trans_Comp_OpenSession_Func_1000, TestSize.Level3)
493 {
494 int ret;
495 int sessionId;
496 int timeout = 10;
497
498 string data = "send stream transmission test!!!!";
499 char *sendData = (char *)malloc(data.length() + 1);
500 EXPECT_NE(sendData, nullptr);
501 ret = strcpy_s(sendData, data.length() + 1, data.c_str());
502 EXPECT_EQ(ret, SOFTBUS_OK);
503 StreamData extStreamData {0};
504 StreamData streamData {
505 .buf = sendData,
506 .bufLen = data.length() + 1,
507 };
508 StreamFrameInfo frame = {0};
509
510 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_FILE, &g_fileSessionListener);
511 EXPECT_EQ(SOFTBUS_OK, ret) << "call CreateSS[file] fail";
512
513 sessionId = OpenSession(SESSION_NAME_FILE, SESSION_NAME_FILE, GetNetworkId(), DEF_GROUP_ID, &g_fileSessionAttr);
514 if (sessionId < SESSION_ID_MIN)
515 {
516 LOG("call opensession[stream] fail, ret sid:%d, netid:%s", sessionId, GetNetworkId());
517 }
518 ret = Wait4Session(timeout, SESSION_4STREAM);
519 if (ret != SOFTBUS_OK)
520 {
521 LOG("call opensession[stream] fail");
522 }
523
524 ret = SendStream(sessionId, &streamData, &extStreamData, &frame);
525 EXPECT_NE(SOFTBUS_OK, ret) << "sendstream succees";
526
527 CloseSession(sessionId);
528
529 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_STREAM);
530 EXPECT_EQ(SOFTBUS_OK, ret) << "remove Ss fail";
531 }