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