1 /*
2  * Copyright (c) 2022 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 <cstdio>
19 #include <cstdlib>
20 #include <cstring>
21 #include <ctime>
22 #include <cinttypes>
23 #include <iostream>
24 #include <semaphore.h>
25 #include <string>
26 #include <unistd.h>
27 #include <unordered_map>
28 #include <unordered_set>
29 
30 #include "common_list.h"
31 #include "inner_session.h"
32 #include "securec.h"
33 #include "session.h"
34 #include "softbus_adapter_mem.h"
35 #include "softbus_adapter_timer.h"
36 #include "softbus_bus_center.h"
37 #include "softbus_common.h"
38 #include "softbus_def.h"
39 #include "softbus_errcode.h"
40 #include "softbus_feature_config.h"
41 #include "softbus_file_test_entry.h"
42 #include "softbus_utils.h"
43 
44 using namespace testing::ext;
45 using namespace std;
46 namespace OHOS {
47 
48 const std::string FILE_TEST_PKG_NAME = "com.huawei.plrdtest.dsoftbus";
49 const std::string FILE_TEST_PKG_NAME_DEMO = "com.huawei.plrdtest.dsoftbus1";
50 const std::string FILE_SESSION_NAME = "com.huawei.plrdtest.dsoftbus.JtSendFile_10";
51 const std::string FILE_SESSION_NAME_DEMO = "com.huawei.plrdtest.dsoftbus.JtSendFile_demo";
52 
53 const int SEND_DATA_SIZE_1K = 1024;
54 const int SEND_DATA_SIZE_4K = 4 * 1024;
55 const int SEND_DATA_SIZE_1M = 1024 * 1024;
56 const char *g_testData = "{\"data\":\"open session test!!!\"}";
57 
58 const char *SFILE_NAME_ERR = "/data/errFileName";
59 const char *SFILE_NAME_1K = "/data/file1K.tar";
60 const char *SFILE_NAME_5M = "/data/file5M.tar";
61 const char *SFILE_NAME_5M1 = "/data/file5M1.tar";
62 
63 const char *DFILE_NAME_1K = "file1K.tar";
64 const char *DFILE_NAME_1K_2 = "file1K_2.tar";
65 const char *DFILE_NAME_1K_3 = "file1K_3.tar";
66 const char *DFILE_NAME_5M = "file5M.tar";
67 const char *DFILE_NAME_5M_2 = "file5M_2.tar";
68 const char *DFILE_NAME_5M_3 = "file5M_3.tar";
69 const char *DFILE_NAME_5M1 = "file5M1.tar";
70 const char *RECV_ROOT_PATH = "/data/recv/";
71 
72 const int OPEN_SESSION_SEM_WAIT_TIME = 10;
73 
74 const int WSLEEP_SEC_TYPE = 1;
75 const int WSLEEP_SEC_UNIT = 1;
76 const int WSLEEP_COMM_TIME = 2;
77 const int WSLEEP_SEM_WAIT_TIME = 4;
78 
79 const int WSLEEP_MSEC_TYPE = 2;
80 const int WSLEEP_MSEC_UNIT = 1000;
81 const int WSLEEP_SEND_BYTES_TIME = 10;
82 const int WSLEEP_PTHREAD_SEND_FILE_WAIT_TIME = 500;
83 const uint32_t TEST_SEND_FILE_COUNT = 2;
84 
85 struct TransTestInfo {
86     string mySessionName;
87     string peerSessionName;
88     int32_t testCnt;
89     int32_t sendNum;
90     int32_t dataType;
91     const char **sfileList;
92     const char **dfileList;
93     int32_t sfileCnt;
94 };
95 
96 unordered_set<string> networkIdSet_;
97 unordered_set<int32_t> sessionSet_;
98 sem_t localSem_;
99 int32_t openSessionSuccessCnt_ = 0;
100 const SoftbusTestEntry *testEntryArgs_ = nullptr;
101 
102 const int WAIT_ONLINE_TIME = 5;
103 const int GET_LNN_RETRY_COUNT = 5;
WaitDeviceOnline(const char * pkgName)104 int32_t WaitDeviceOnline(const char *pkgName)
105 {
106     int32_t onlineRetryCount = 0;
107     int32_t ret;
108     while (true) {
109         NodeBasicInfo *onlineDevices = nullptr;
110         int32_t onlineNum = 0;
111         ret = GetAllNodeDeviceInfo(pkgName, &onlineDevices, &onlineNum);
112         onlineRetryCount++;
113         if (onlineRetryCount < GET_LNN_RETRY_COUNT && (ret != SOFTBUS_OK || onlineNum <= 0)) {
114             FreeNodeInfo(onlineDevices);
115             sleep(WAIT_ONLINE_TIME);
116             continue;
117         }
118         cout << "online device num: " << onlineNum << endl;
119         for (int32_t i = 0; i < onlineNum; i++) {
120             networkIdSet_.insert(string(onlineDevices[i].networkId));
121             cout << "online idex " << i << " : " << string(onlineDevices[i].networkId) << endl;
122         }
123         FreeNodeInfo(onlineDevices);
124         break;
125     }
126     if (!networkIdSet_.empty()) {
127         return SOFTBUS_OK;
128     }
129     return SOFTBUS_TIMOUT;
130 }
131 
OnSessionOpened(int sessionId,int result)132 int OnSessionOpened(int sessionId, int result)
133 {
134     cout << "session opened, sesison id = " << sessionId << ", result = " << result << endl;
135     if (result == SOFTBUS_OK) {
136         sessionSet_.insert(sessionId);
137         openSessionSuccessCnt_++;
138     }
139     sem_post(&localSem_);
140     return SOFTBUS_OK;
141 }
142 
OnSessionClosed(int sessionId)143 void OnSessionClosed(int sessionId)
144 {
145     cout << "session closed, sesison id = " << sessionId << endl;
146     sessionSet_.erase(sessionId);
147 }
148 
OnStreamReceived(int sessionId,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)149 void OnStreamReceived(int sessionId, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)
150 {
151     if (data == nullptr) {
152         printf("StreamData is null, stream received fail\n");
153         return;
154     }
155     printf("stream received, sessionid[%d], data = %.*s\n", sessionId, data->bufLen, data->buf);
156     if (ext == nullptr || ext->buf == nullptr || data->bufLen <= 0) {
157         printf("parameters invalid, stream received fail\n");
158         return;
159     }
160     printf("stream received, sessionid[%d], extdata = %.*s\n", sessionId, ext->bufLen, ext->buf);
161 }
162 
OnBytesReceived(int sessionId,const void * data,unsigned int len)163 void OnBytesReceived(int sessionId, const void *data, unsigned int len)
164 {
165     if (testEntryArgs_->testSide_ == PASSIVE_OPENSESSION_WAY) {
166         SendBytes(sessionId, "{\"received ok\"}", strlen("{\"received ok\"}"));
167     }
168     printf("bytes received, sessionid[%d], data[%s], dataLen[%u]\n", sessionId, data, len);
169 }
170 
OnMessageReceived(int sessionId,const void * data,unsigned int len)171 void OnMessageReceived(int sessionId, const void *data, unsigned int len)
172 {
173     printf("msg received, sessionid[%d], data[%s], dataLen[%u]\n", sessionId, data, len);
174 }
175 
176 static ISessionListener g_listener = {
177     .OnSessionOpened = OnSessionOpened,
178     .OnSessionClosed = OnSessionClosed,
179     .OnStreamReceived = OnStreamReceived,
180     .OnBytesReceived = OnBytesReceived,
181     .OnMessageReceived = OnMessageReceived
182 };
183 
OnSendFileProcess(int sessionId,uint64_t bytesUpload,uint64_t bytesTotal)184 int OnSendFileProcess(int sessionId, uint64_t bytesUpload, uint64_t bytesTotal)
185 {
186     cout << "send process id = " << sessionId << ", upload = " << bytesUpload << ", total = " << bytesTotal << endl;
187     return 0;
188 }
189 
OnSendFileFinished(int sessionId,const char * firstFile)190 int OnSendFileFinished(int sessionId, const char *firstFile)
191 {
192     printf("send finished id = %d, first file = %s\n", sessionId, firstFile);
193     return 0;
194 }
195 
OnFileTransError(int sessionId)196 void OnFileTransError(int sessionId)
197 {
198     printf("OnFileTransError sessionId = %d\n", sessionId);
199 }
200 
201 static IFileSendListener g_fileSendListener = {
202     .OnSendFileProcess = OnSendFileProcess,
203     .OnSendFileFinished = OnSendFileFinished,
204     .OnFileTransError = OnFileTransError,
205 };
206 
OnReceiveFileStarted(int sessionId,const char * files,int fileCnt)207 int OnReceiveFileStarted(int sessionId, const char *files, int fileCnt)
208 {
209     printf("File receive start sessionId = %d, first file = %s, fileCnt = %d\n", sessionId, files, fileCnt);
210     return 0;
211 }
212 
OnReceiveFileFinished(int sessionId,const char * files,int fileCnt)213 void OnReceiveFileFinished(int sessionId, const char *files, int fileCnt)
214 {
215     printf("File receive finished sessionId = %d, first file = %s, fileCnt = %d\n", sessionId, files, fileCnt);
216 }
217 
OnReceiveFileProcess(int sessionId,const char * firstFile,uint64_t bytesUpload,uint64_t bytesTotal)218 int OnReceiveFileProcess(int sessionId, const char *firstFile, uint64_t bytesUpload, uint64_t bytesTotal)
219 {
220     printf("File receive process sessionId = %d, first file = %s, upload = %" PRIu64 ", total = %" PRIu64 "\n",
221         sessionId, firstFile, bytesUpload, bytesTotal);
222     return 0;
223 }
224 static IFileReceiveListener g_fileRecvListener = {
225     .OnReceiveFileStarted = OnReceiveFileStarted,
226     .OnReceiveFileFinished = OnReceiveFileFinished,
227     .OnReceiveFileProcess = OnReceiveFileProcess,
228     .OnFileTransError = OnFileTransError,
229 };
230 
231 class AuthSessionTest : public testing::Test {
232 public:
AuthSessionTest()233     AuthSessionTest()
234     {}
~AuthSessionTest()235     ~AuthSessionTest()
236     {}
237     static void SetUpTestCase(void);
238     static void TearDownTestCase(void);
239     void SetUp();
240     void TearDown();
241 
242     static void Wsleep(uint32_t count, int32_t usl);
243     static void ServerWait(int32_t waitTime);
244     static void OpenAllSession(int32_t dataType, const string &mySessionName, const string &peerSessionName);
245     static void TestServerSide(void);
246 
247     static void CloseAllSession(void);
248     static void TestSendMessage(int32_t sendCnt, const char *data, uint32_t len, bool ex = false);
249     static void TestSendBytes(int32_t sendCnt, const char *data, uint32_t len, bool ex = false);
250 
251     static void TestSendFile(int32_t sendCnt, const char *sfileList[], const char *dfileList[],
252         int32_t cnt, bool ex = false);
253 
254     static void TransTest(struct TransTestInfo &transInfo, int32_t testDataType, bool ex = false);
255     static void *TestSendFileThread(void *arg);
256 };
257 
SetUpTestCase(void)258 void AuthSessionTest::SetUpTestCase(void)
259 {
260     SoftbusConfigInit();
261     int32_t ret = sem_init(&localSem_, 0, 0);
262     ASSERT_EQ(ret, 0);
263     testEntryArgs_ = GetTestEntry();
264     ASSERT_NE(testEntryArgs_, nullptr);
265 
266     networkIdSet_.clear();
267     ret = SOFTBUS_TIMOUT;
268     if (testEntryArgs_->testSide_ == PASSIVE_OPENSESSION_WAY) {
269         ret = WaitDeviceOnline(FILE_TEST_PKG_NAME.c_str());
270         ASSERT_EQ(ret, SOFTBUS_OK);
271     } else if (testEntryArgs_->testSide_ == ACTIVE_OPENSESSION_WAY) {
272         ret = WaitDeviceOnline(FILE_TEST_PKG_NAME.c_str());
273         ASSERT_EQ(ret, SOFTBUS_OK);
274     } else if (testEntryArgs_->testSide_ == ACTIVE_ANOTHER_OPENSESSION_WAY) {
275         ret = WaitDeviceOnline(FILE_TEST_PKG_NAME_DEMO.c_str());
276         ASSERT_EQ(ret, SOFTBUS_OK);
277     } else {
278         ASSERT_EQ(ret, SOFTBUS_OK);
279     }
280 }
281 
TearDownTestCase(void)282 void AuthSessionTest::TearDownTestCase(void)
283 {
284     sessionSet_.clear();
285     int32_t ret = sem_destroy(&localSem_);
286     ASSERT_EQ(ret, 0);
287     Wsleep(WSLEEP_COMM_TIME, WSLEEP_SEC_TYPE);
288 }
289 
SetUp(void)290 void AuthSessionTest::SetUp(void)
291 {
292     sessionSet_.clear();
293     openSessionSuccessCnt_ = 0;
294 }
295 
TearDown(void)296 void AuthSessionTest::TearDown(void)
297 {
298     sessionSet_.clear();
299     openSessionSuccessCnt_ = 0;
300 }
301 
Wsleep(uint32_t count,int32_t usl)302 void AuthSessionTest::Wsleep(uint32_t count, int32_t usl)
303 {
304     while (count) {
305         if (usl == WSLEEP_SEC_TYPE) {
306             sleep(WSLEEP_SEC_UNIT);
307         } else {
308             usleep(WSLEEP_MSEC_UNIT);
309         }
310         count--;
311     }
312 }
ServerWait(int32_t waitTime)313 void AuthSessionTest::ServerWait(int32_t waitTime)
314 {
315     cout << "waitTime = " << waitTime << endl;
316     int32_t ret = sem_wait(&localSem_);
317     EXPECT_EQ(ret, 0);
318     int32_t i = 0;
319     while (i++ < waitTime) {
320         Wsleep(WSLEEP_SEM_WAIT_TIME, WSLEEP_SEC_TYPE);
321     }
322     if (i >= waitTime) {
323         ADD_FAILURE();
324     }
325 }
326 
OpenAllSession(int32_t dataType,const string & mySessionName,const string & peerSessionName)327 void AuthSessionTest::OpenAllSession(int32_t dataType, const string &mySessionName, const string &peerSessionName)
328 {
329     for (auto networkId : networkIdSet_) {
330         SessionAttribute attribute;
331         (void)memset_s(&attribute, sizeof(attribute), 0, sizeof(attribute));
332         attribute.dataType = dataType;
333         int32_t ret = OpenSession(mySessionName.c_str(), peerSessionName.c_str(), networkId.c_str(), "", &attribute);
334         ASSERT_GT(ret, 0);
335         struct timespec timeout;
336         clock_gettime(CLOCK_REALTIME, &timeout);
337         timeout.tv_sec += OPEN_SESSION_SEM_WAIT_TIME;
338         while ((ret = sem_timedwait(&localSem_, &timeout)) == -1 && errno == EINTR) {
339             cout << "wait interrupted system call" << endl;
340             continue;
341         }
342         ASSERT_EQ(ret, 0);
343         if (ret == -1 && errno == ETIMEDOUT) {
344             cout << "wait time out" << endl;
345         }
346     }
347 }
CloseAllSession(void)348 void AuthSessionTest::CloseAllSession(void)
349 {
350     for (auto session : sessionSet_) {
351         CloseSession(session);
352     }
353     sessionSet_.clear();
354     Wsleep(WSLEEP_COMM_TIME, WSLEEP_SEC_TYPE);
355 }
356 
TestServerSide(void)357 void AuthSessionTest::TestServerSide(void)
358 {
359     int32_t ret = CreateSessionServer(FILE_TEST_PKG_NAME.c_str(), FILE_SESSION_NAME.c_str(), &g_listener);
360     ASSERT_EQ(ret, SOFTBUS_OK);
361     ret = CreateSessionServer(FILE_TEST_PKG_NAME.c_str(), FILE_SESSION_NAME_DEMO.c_str(), &g_listener);
362     ASSERT_EQ(ret, SOFTBUS_OK);
363     ret = SetFileReceiveListener(FILE_TEST_PKG_NAME.c_str(), FILE_SESSION_NAME.c_str(),
364         &g_fileRecvListener, RECV_ROOT_PATH);
365     ASSERT_EQ(ret, SOFTBUS_OK);
366     ret = SetFileReceiveListener(FILE_TEST_PKG_NAME.c_str(), FILE_SESSION_NAME_DEMO.c_str(),
367         &g_fileRecvListener, RECV_ROOT_PATH);
368     ASSERT_EQ(ret, SOFTBUS_OK);
369     ServerWait(testEntryArgs_->aliveTime_);
370     ret = RemoveSessionServer(FILE_TEST_PKG_NAME.c_str(), FILE_SESSION_NAME.c_str());
371     EXPECT_EQ(ret, SOFTBUS_OK);
372     ret = RemoveSessionServer(FILE_TEST_PKG_NAME.c_str(), FILE_SESSION_NAME_DEMO.c_str());
373     EXPECT_EQ(ret, SOFTBUS_OK);
374 }
375 
TestSendMessage(int32_t sendCnt,const char * data,uint32_t len,bool ex)376 void AuthSessionTest::TestSendMessage(int32_t sendCnt, const char *data, uint32_t len, bool ex)
377 {
378     for (auto session : sessionSet_) {
379         cout << "send message, session id = " << session << endl;
380         int32_t ret;
381         for (int32_t i = 0; i < sendCnt; i++) {
382             ret = SendMessage(session, data, len);
383             if (ex) {
384                 ASSERT_NE(ret, SOFTBUS_OK);
385             } else {
386                 if (ret != SOFTBUS_OK && ret != SOFTBUS_TIMOUT) {
387                     EXPECT_EQ(ret, SOFTBUS_OK);
388                 }
389                 Wsleep(WSLEEP_SEND_BYTES_TIME, WSLEEP_MSEC_TYPE);
390             }
391         }
392     }
393     Wsleep(WSLEEP_COMM_TIME, WSLEEP_SEC_TYPE);
394 }
TestSendBytes(int32_t sendCnt,const char * data,uint32_t len,bool ex)395 void AuthSessionTest::TestSendBytes(int32_t sendCnt, const char *data, uint32_t len, bool ex)
396 {
397     for (auto session : sessionSet_) {
398         cout << "send bytes, session id = " << session << endl;
399         int32_t ret;
400         for (int32_t i = 0; i < sendCnt; i++) {
401             ret = SendBytes(session, data, len);
402             if (ex) {
403                 ASSERT_NE(ret, SOFTBUS_OK);
404             } else {
405                 EXPECT_EQ(ret, SOFTBUS_OK);
406                 Wsleep(WSLEEP_SEND_BYTES_TIME, WSLEEP_MSEC_TYPE);
407             }
408         }
409     }
410     Wsleep(WSLEEP_COMM_TIME, WSLEEP_SEC_TYPE);
411 }
TestSendFile(int32_t sendCnt,const char * sfileList[],const char * dfileList[],int32_t cnt,bool ex)412 void AuthSessionTest::TestSendFile(int32_t sendCnt, const char *sfileList[], const char *dfileList[],
413     int32_t cnt, bool ex)
414 {
415     for (auto session : sessionSet_) {
416         cout << "send file, session id = " << session << endl;
417         int32_t ret;
418         for (int32_t i = 0; i < sendCnt; i++) {
419             ret = SendFile(session, sfileList, dfileList, cnt);
420             if (ex) {
421                 ASSERT_NE(ret, SOFTBUS_OK);
422             } else {
423                 EXPECT_EQ(ret, SOFTBUS_OK);
424                 Wsleep(WSLEEP_COMM_TIME, WSLEEP_SEC_TYPE);
425             }
426         }
427     }
428     if (!ex) {
429         Wsleep(WSLEEP_COMM_TIME, WSLEEP_SEC_TYPE);
430         Wsleep(WSLEEP_COMM_TIME, WSLEEP_SEC_TYPE);
431     }
432 }
433 
TransTest(struct TransTestInfo & transInfo,int32_t testDataType,bool ex)434 void AuthSessionTest::TransTest(struct TransTestInfo &transInfo, int32_t testDataType, bool ex)
435 {
436     cout << "testCnt = " << transInfo.sendNum << endl;
437     OpenAllSession(transInfo.dataType, transInfo.mySessionName, transInfo.peerSessionName);
438     if (testDataType == TYPE_BYTES) {
439         char *data = (char *)malloc(SEND_DATA_SIZE_1M);
440         ASSERT_NE(data, nullptr);
441         (void)memset_s(data, SEND_DATA_SIZE_1M, 0, SEND_DATA_SIZE_1M);
442         ASSERT_NE(data, nullptr);
443         int32_t ret = memcpy_s(data, SEND_DATA_SIZE_1M, g_testData, strlen(g_testData));
444         EXPECT_EQ(ret, EOK);
445         TestSendBytes(transInfo.sendNum, data, ex ? SEND_DATA_SIZE_1M : SEND_DATA_SIZE_4K, ex);
446         free(data);
447     } else if (testDataType == TYPE_MESSAGE) {
448         char *data = (char *)malloc(SEND_DATA_SIZE_1M);
449         ASSERT_NE(data, nullptr);
450         (void)memset_s(data, SEND_DATA_SIZE_1M, 0, SEND_DATA_SIZE_1M);
451         ASSERT_NE(data, nullptr);
452         int32_t ret = memcpy_s(data, SEND_DATA_SIZE_1M, g_testData, strlen(g_testData));
453         EXPECT_EQ(ret, EOK);
454         TestSendMessage(transInfo.sendNum, data, ex ? SEND_DATA_SIZE_1M : SEND_DATA_SIZE_1K, ex);
455         free(data);
456     } else if (testDataType == TYPE_FILE) {
457         TestSendFile(transInfo.sendNum, transInfo.sfileList, transInfo.dfileList, transInfo.sfileCnt, ex);
458     } else if (testDataType == TYPE_STREAM) {
459         Wsleep(WSLEEP_SEND_BYTES_TIME, WSLEEP_MSEC_TYPE);
460         CloseAllSession();
461         return;
462     }
463     if (!ex) {
464         Wsleep(WSLEEP_COMM_TIME, WSLEEP_SEC_TYPE);
465     }
466     CloseAllSession();
467 }
468 
469 /*
470 * @tc.name: testSendFile001
471 * @tc.desc:
472 * @tc.type: FUNC
473 * @tc.require:
474 */
475 HWTEST_F(AuthSessionTest, testSendFile001, TestSize.Level1)
476 {
477     if (testEntryArgs_->testSide_ == PASSIVE_OPENSESSION_WAY) {
478         TestServerSide();
479         return;
480     }
481     const char *sfileList[10] = {nullptr};
482     const char *dfileList[10] = {nullptr};
483     sfileList[0] = SFILE_NAME_1K;
484     sfileList[1] = SFILE_NAME_5M;
485     dfileList[0] = DFILE_NAME_1K;
486     dfileList[1] = DFILE_NAME_5M;
487     struct TransTestInfo transInfo = {
488         .testCnt = 1,
489         .sendNum = 1,
490         .dataType = TYPE_FILE,
491         .sfileList = sfileList,
492         .dfileList = dfileList,
493         .sfileCnt = 2,
494     };
495     std::string pkgName;
496     if (testEntryArgs_->testSide_ == ACTIVE_OPENSESSION_WAY) {
497         pkgName = FILE_TEST_PKG_NAME;
498         transInfo.mySessionName = FILE_SESSION_NAME;
499         transInfo.peerSessionName = FILE_SESSION_NAME;
500     } else if (testEntryArgs_->testSide_ == ACTIVE_ANOTHER_OPENSESSION_WAY) {
501         pkgName = FILE_TEST_PKG_NAME_DEMO;
502         transInfo.mySessionName = FILE_SESSION_NAME_DEMO;
503         transInfo.peerSessionName = FILE_SESSION_NAME_DEMO;
504     } else {
505         return;
506     }
507 
508     int32_t ret = CreateSessionServer(pkgName.c_str(), transInfo.mySessionName.c_str(), &g_listener);
509     ASSERT_EQ(ret, SOFTBUS_OK);
510     ret = SetFileSendListener(pkgName.c_str(), transInfo.mySessionName.c_str(), &g_fileSendListener);
511     ASSERT_EQ(ret, SOFTBUS_OK);
512     TransTest(transInfo, TYPE_FILE);
513     ret = RemoveSessionServer(pkgName.c_str(), transInfo.mySessionName.c_str());
514     EXPECT_EQ(ret, SOFTBUS_OK);
515 };
516 
TestSendFileThread(void * arg)517 void *AuthSessionTest::TestSendFileThread(void *arg)
518 {
519     Wsleep(WSLEEP_PTHREAD_SEND_FILE_WAIT_TIME, WSLEEP_MSEC_TYPE);
520     cout << "TestSendFileThread start" << endl;
521     const char *sfileList[TEST_SEND_FILE_COUNT + 1] = {nullptr};
522     const char *dfileList[TEST_SEND_FILE_COUNT + 1] = {nullptr};
523     sfileList[0] = SFILE_NAME_1K;
524     sfileList[1] = SFILE_NAME_5M;
525     dfileList[0] = DFILE_NAME_1K_3;
526     dfileList[1] = DFILE_NAME_5M_3;
527     TestSendFile(1, sfileList, dfileList, TEST_SEND_FILE_COUNT);
528     cout << "TestSendFileThread end" << endl;
529     return nullptr;
530 }
531 /*
532 * @tc.name: testSendFile002
533 * @tc.desc:
534 * @tc.type: FUNC
535 * @tc.require:
536 */
537 HWTEST_F(AuthSessionTest, testSendFile002, TestSize.Level1)
538 {
539     if (testEntryArgs_->testSide_ == PASSIVE_OPENSESSION_WAY) {
540         TestServerSide();
541         return;
542     }
543     std::string pkgName;
544     std::string mySessionName;
545     std::string peerSessionName;
546     if (testEntryArgs_->testSide_ == ACTIVE_OPENSESSION_WAY) {
547         pkgName = FILE_TEST_PKG_NAME;
548         mySessionName = FILE_SESSION_NAME;
549         peerSessionName = FILE_SESSION_NAME;
550     } else if (testEntryArgs_->testSide_ == ACTIVE_ANOTHER_OPENSESSION_WAY) {
551         pkgName = FILE_TEST_PKG_NAME_DEMO;
552         mySessionName = FILE_SESSION_NAME_DEMO;
553         peerSessionName = FILE_SESSION_NAME_DEMO;
554     } else {
555         return;
556     }
557 
558     int32_t ret = CreateSessionServer(pkgName.c_str(), mySessionName.c_str(), &g_listener);
559     ASSERT_EQ(ret, SOFTBUS_OK);
560     ret = SetFileSendListener(pkgName.c_str(), mySessionName.c_str(), &g_fileSendListener);
561     ASSERT_EQ(ret, SOFTBUS_OK);
562     const char *sfileList[TEST_SEND_FILE_COUNT + 1] = {nullptr};
563     const char *dfileList[TEST_SEND_FILE_COUNT + 1] = {nullptr};
564     sfileList[0] = SFILE_NAME_1K;
565     sfileList[1] = SFILE_NAME_5M;
566     dfileList[0] = DFILE_NAME_1K_2;
567     dfileList[1] = DFILE_NAME_5M_2;
568     OpenAllSession(TYPE_FILE, mySessionName, peerSessionName);
569     pthread_t tid;
570     int32_t createPthreadRet = pthread_create(&tid, nullptr, AuthSessionTest::TestSendFileThread, nullptr);
571     EXPECT_EQ(createPthreadRet, 0);
572     cout << "TestSendFile start" << endl;
573     TestSendFile(1, sfileList, dfileList, TEST_SEND_FILE_COUNT);
574     cout << "TestSendFile end" << endl;
575     if (createPthreadRet == 0 && pthread_join(tid, nullptr) != 0) {
576         cout << "join thread error" << endl;
577     }
578     CloseAllSession();
579     ret = RemoveSessionServer(pkgName.c_str(), mySessionName.c_str());
580     EXPECT_EQ(ret, SOFTBUS_OK);
581 };
582 
583 /*
584 * @tc.name: testOpenSessionEx001
585 * @tc.desc:
586 * @tc.type: FUNC
587 * @tc.require:
588 */
589 HWTEST_F(AuthSessionTest, testSendFileEx001, TestSize.Level1)
590 {
591     if (testEntryArgs_->testSide_ == PASSIVE_OPENSESSION_WAY) {
592         TestServerSide();
593         return;
594     }
595     const char *sfileList[1] = {nullptr};
596     const char *dfileList[1] = {nullptr};
597     sfileList[0] = SFILE_NAME_ERR;
598     dfileList[0] = SFILE_NAME_ERR;
599     struct TransTestInfo transInfo = {
600         .testCnt = 1,
601         .sendNum = 1,
602         .dataType = TYPE_FILE,
603         .sfileList = sfileList,
604         .dfileList = dfileList,
605         .sfileCnt = 1,
606     };
607     std::string pkgName;
608     if (testEntryArgs_->testSide_ == ACTIVE_OPENSESSION_WAY) {
609         pkgName = FILE_TEST_PKG_NAME;
610         transInfo.mySessionName = FILE_SESSION_NAME;
611         transInfo.peerSessionName = FILE_SESSION_NAME;
612     } else if (testEntryArgs_->testSide_ == ACTIVE_ANOTHER_OPENSESSION_WAY) {
613         pkgName = FILE_TEST_PKG_NAME_DEMO;
614         transInfo.mySessionName = FILE_SESSION_NAME_DEMO;
615         transInfo.peerSessionName = FILE_SESSION_NAME_DEMO;
616     } else {
617         return;
618     }
619 
620     int32_t ret = CreateSessionServer(pkgName.c_str(), transInfo.mySessionName.c_str(), &g_listener);
621     ASSERT_EQ(ret, SOFTBUS_OK);
622     ret = SetFileSendListener(pkgName.c_str(), transInfo.mySessionName.c_str(), &g_fileSendListener);
623     ASSERT_EQ(ret, SOFTBUS_OK);
624 
625     TransTest(transInfo, TYPE_FILE, true);
626 
627     sfileList[0] = SFILE_NAME_5M1;
628     dfileList[0] = DFILE_NAME_5M1;
629     TransTest(transInfo, TYPE_FILE, true);
630 
631     sfileList[0] = SFILE_NAME_5M1;
632     transInfo.dfileList = nullptr;
633     TransTest(transInfo, TYPE_FILE, true);
634 
635     ret = RemoveSessionServer(pkgName.c_str(), transInfo.mySessionName.c_str());
636     EXPECT_EQ(ret, SOFTBUS_OK);
637 };
638 } // namespace OHOS