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 "net_trans_common.h"
19 #include "wifi_utils.h"
20 #include "softbus_errcode.h"
21
22 using namespace testing::ext;
23
24 static const int EXPECT_INVALID_PARAM = SOFTBUS_INVALID_PARAM;
25
26 class TransReliabilityTest : public testing::Test {
27 public:
28 static void SetUpTestCase();
29 static void TearDownTestCase();
30 void SetUp();
31 void TearDown();
32 };
33
SetUp()34 void TransReliabilityTest::SetUp() {}
35
TearDown()36 void TransReliabilityTest::TearDown() {}
37
SetUpTestCase()38 void TransReliabilityTest::SetUpTestCase()
39 {
40 LOG("SetUp begin");
41 AddPermission();
42 sleep(1);
43 system("pidof accesstoken_ser | xargs kill -9");
44 sleep(1);
45 TestSetUp();
46
47 int ret = RegisterDeviceStateDefCallback();
48 EXPECT_EQ(SOFTBUS_OK, ret) << "call reg node state callback fail";
49
50 ret = CheckRemoteDeviceIsNull(BOOL_TRUE);
51 ASSERT_EQ(SOFTBUS_OK, ret) << "get node fail,please check network";
52
53 LOG("SetUp end");
54 }
55
TearDownTestCase()56 void TransReliabilityTest::TearDownTestCase()
57 {
58 int ret = UnRegisterDeviceStateDefCallback();
59 EXPECT_EQ(SOFTBUS_OK, ret) << "call unReg node state callback fail";
60
61 TestTearDown();
62 }
63
64 /**
65 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli__0100
66 * @tc.name : SessionId doesn’t exist，Failed to send byte
67 * @tc.desc : Test Transceiver data reliability
68 * @tc.type : RELI
69 * @tc.size : MediumTest
70 */
71 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli__0100, TestSize.Level3)
72 {
73 int ret;
74 int sessionId = 0;
75 string data = "invalid session id";
76 ret = SendBytes(sessionId, data.c_str(), data.length());
77 EXPECT_EQ(SOFTBUS_TRANS_INVALID_SESSION_ID, ret);
78 }
79
80 /**
81 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli__0200
82 * @tc.name : SessionId closed，Failed to send byte
83 * @tc.desc : Test Transceiver data reliability
84 * @tc.type : RELI
85 * @tc.size : MediumTest
86 */
87 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli__0200, TestSize.Level3)
88 {
89 int ret;
90 ret = CreateSsAndOpenSession4Data();
91 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
92
93 int sessionId = GetCurrentSessionId4Data();
94 ret = CloseSessionAndRemoveSs4Data();
95 ASSERT_EQ(SOFTBUS_OK, ret);
96
97 string data = "session closed";
98 ret = SendBytes(sessionId, data.c_str(), data.length());
99 EXPECT_EQ(SOFTBUS_TRANS_INVALID_SESSION_ID, ret);
100 }
101
102 /**
103 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli__0300
104 * @tc.name : send data during OpenSession
105 * @tc.desc : Test Transceiver data reliability
106 * @tc.type : FUNC
107 * @tc.size : MediumTest
108 */
109 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli__0300, TestSize.Level3)
110 {
111 int ret;
112 char* softbusPidStart;
113 char* softbusPidEnd;
114 softbusPidStart = GetSoftbusPid();
115 EXPECT_TRUE(softbusPidStart != NULL);
116
117 const int count = 4;
118 int sessionId4Data[count];
119 int sessionId4Ctrl[count];
120 char groupId[][GROUP_ID_LEN] = { "g1", "g2", "g3", "g4" };
121 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_CTL, GetSessionListenser4Ctl());
122 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS-ctrl fail";
123 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, GetSessionListenser4Data());
124 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS-data fail";
125 for (int i = 0; i < count; i++) {
126 sessionId4Data[i] =
127 OpenSession(SESSION_NAME_DATA, SESSION_NAME_DATA, GetNetworkId(), groupId[i], GetSessionAttr4Data());
128 sessionId4Ctrl[i] =
129 OpenSession(SESSION_NAME_CTL, SESSION_NAME_CTL, GetNetworkId(), groupId[i], GetSessionAttr4Ctl());
130 }
131
132 // send data
133 char* sendData = (char*)malloc(TRANS_BYTES_LENGTH_MAX);
134 ASSERT_TRUE(sendData != NULL);
135 (void)memset_s(sendData, TRANS_BYTES_LENGTH_MAX, 'C', TRANS_BYTES_LENGTH_MAX);
136 for (int i = 0; i < count; i++) {
137 ret = SendBytes(sessionId4Data[i], sendData, TRANS_BYTES_LENGTH_MAX);
138 LOG("######sid:%d, send byte:%d", sessionId4Data[i], ret);
139 ret = SendBytes(sessionId4Ctrl[i], sendData, TRANS_BYTES_LENGTH_MAX);
140 LOG("######sid:%d, send byte:%d", sessionId4Ctrl[i], ret);
141 }
142 for (int i = 0; i < count; i++) {
143 ret = SendMessage(sessionId4Data[i], sendData, TRANS_BYTES_LENGTH_MAX);
144 LOG("######sid:%d, send msg:%d", sessionId4Data[i], ret);
145 ret = SendMessage(sessionId4Ctrl[i], sendData, TRANS_BYTES_LENGTH_MAX);
146 LOG("######sid:%d, send msg:%d", sessionId4Ctrl[i], ret);
147 }
148
149 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_CTL);
150 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSessionServer fail";
151 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
152 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSessionServer fail";
153
154 softbusPidEnd = GetSoftbusPid();
155 EXPECT_TRUE(softbusPidEnd != NULL);
156 EXPECT_STREQ(softbusPidStart, softbusPidEnd);
157 free(softbusPidStart);
158 free(softbusPidEnd);
159 free(sendData);
160 }
161
162 /**
163 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli__0400
164 * @tc.name : SessionId doesn’t exist，Failed to send Message
165 * @tc.desc : Test Transceiver data reliability
166 * @tc.type : RELI
167 * @tc.size : MediumTest
168 */
169 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli__0400, TestSize.Level3)
170 {
171 int ret;
172 int sessionId = 0;
173 string data = "invalid session id";
174 ret = SendMessage(sessionId, data.c_str(), data.length());
175 EXPECT_EQ(SOFTBUS_TRANS_INVALID_SESSION_ID, ret);
176 }
177
178 /**
179 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_0500
180 * @tc.name : CreateSessionServer repeatedly
181 * @tc.desc : Test session management reliability
182 * @tc.type : RELI
183 * @tc.size : MediumTest
184 */
185 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_0500, TestSize.Level3)
186 {
187 int ret;
188 char sessionNames[][SESSION_NAME_SIZE_MAX] = { "com.communication.demo1.1", "com.communication.demo1.2",
189 "com.communication.demo1.3", "com.communication.demo1.4", "com.communication.demo1.5",
190 "com.communication.demo1.6", "com.communication.demo1.7", "com.communication.demo1.8" };
191
192 for (int i = 0; i < MAX_SESSION_SERVER_NUM_CLIENT; i++) {
193 ret = CreateSessionServer(DEF_PKG_NAME, sessionNames[i], GetSessionListenser4Data());
194 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS fail,i=" << i;
195 }
196
197 // repeat once, expect success
198 for (int i = 0; i < MAX_SESSION_SERVER_NUM_CLIENT; i++) {
199 ret = CreateSessionServer(DEF_PKG_NAME, sessionNames[i], GetSessionListenser4Data());
200 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS success[repeat],i=" << i;
201 }
202
203 for (int i = 0; i < MAX_SESSION_SERVER_NUM_CLIENT; i++) {
204 ret = RemoveSessionServer(DEF_PKG_NAME, sessionNames[i]);
205 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS fail,i=" << i;
206 }
207 }
208
209 /**
210 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_0600
211 * @tc.name : CreateSessionServer input pkg name null
212 * @tc.desc : Test session management reliability
213 * @tc.type : RELI
214 * @tc.size : MediumTest
215 */
216 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_0600, TestSize.Level3)
217 {
218 int ret;
219 ret = CreateSessionServer(NULL, SESSION_NAME_DATA, GetSessionListenser4Data());
220 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "CreateSS[pkg name null]";
221 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
222 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS fail[session listener only malloc]";
223 }
224
225 /**
226 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_0700
227 * @tc.name : CreateSessionServer input session name null
228 * @tc.desc : Test session management reliability
229 * @tc.type : RELI
230 * @tc.size : MediumTest
231 */
232 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_0700, TestSize.Level3)
233 {
234 int ret;
235 ret = CreateSessionServer(DEF_PKG_NAME, NULL, GetSessionListenser4Data());
236 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "CreateSS[session name null]";
237
238 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
239 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS fail[session listener only malloc]";
240 }
241
242 /**
243 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_0800
244 * @tc.name : CreateSessionServer input session listener null
245 * @tc.desc : Test session management reliability
246 * @tc.type : RELI
247 * @tc.size : MediumTest
248 */
249 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_0800, TestSize.Level3)
250 {
251 int ret;
252 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, NULL);
253 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "CreateSS[session listener null]";
254
255 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
256 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS fail[session listener only malloc]";
257 }
258
259 /**
260 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_0900
261 * @tc.name : CreateSessionServer input session listener only malloc
262 * @tc.desc : Test session management reliability
263 * @tc.type : RELI
264 * @tc.size : MediumTest
265 */
266 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_0900, TestSize.Level3)
267 {
268 int ret;
269 ISessionListener* listener = (ISessionListener*)malloc(sizeof(ISessionListener));
270 (void)memset_s(listener, sizeof(ISessionListener), 0, sizeof(ISessionListener));
271 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, listener);
272 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "CreateSS fail[session listener only malloc]";
273 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
274 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS fail[session listener only malloc]";
275
276 free(listener);
277 }
278
279 /**
280 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1000
281 * @tc.name : CreateSessionServer input session listener only malloc
282 * @tc.desc : Test session management reliability
283 * @tc.type : RELI
284 * @tc.size : MediumTest
285 */
286 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1000, TestSize.Level3)
287 {
288 int ret;
289 ISessionListener* listener = (ISessionListener*)malloc(sizeof(ISessionListener));
290
291 listener->OnBytesReceived = NULL;
292 listener->OnMessageReceived = NULL;
293 listener->OnSessionClosed = NULL;
294 listener->OnSessionOpened = NULL;
295 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, listener);
296 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "CreateSS success[session listener member=null]";
297 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
298 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS fail[session listener only malloc]";
299
300 free(listener);
301 }
302
303 /**
304 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1100
305 * @tc.name : RemoveSessionServer input pkg name null
306 * @tc.desc : Test session management reliability
307 * @tc.type : RELI
308 * @tc.size : MediumTest
309 */
310 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1100, TestSize.Level3)
311 {
312 int ret;
313 ret = RemoveSessionServer(NULL, SESSION_NAME_DATA);
314 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret) << "RemoveSS success[pkg name null]";
315
316 }
317
318 /**
319 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1200
320 * @tc.name : RemoveSessionServer input session name null
321 * @tc.desc : Test session management reliability
322 * @tc.type : RELI
323 * @tc.size : MediumTest
324 */
325 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1200, TestSize.Level3)
326 {
327 int ret;
328
329 ret = RemoveSessionServer(DEF_PKG_NAME, NULL);
330 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret) << "RemoveSS success[session name null]";
331 }
332
333 /**
334 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1300
335 * @tc.name : RemoveSessionServer input all null
336 * @tc.desc : Test session management reliability
337 * @tc.type : RELI
338 * @tc.size : MediumTest
339 */
340 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1300, TestSize.Level3)
341 {
342 int ret;
343 ret = RemoveSessionServer(NULL, NULL);
344 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret) << "RemoveSS success[all null]";
345 }
346
347 /**
348 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1400
349 * @tc.name : OpenSession, SessionServer do not exist
350 * @tc.desc : Test session management reliability
351 * @tc.type : RELI
352 * @tc.size : MediumTest
353 */
354 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1400, TestSize.Level3)
355 {
356 int ret;
357 int sessionId;
358 ResetWaitFlag4Data();
359 sessionId = OpenSession(SESSION_NAME_DATA, SESSION_NAME_DATA, GetNetworkId(), DEF_GROUP_ID, GetSessionAttr4Data());
360 EXPECT_TRUE(sessionId < SESSION_ID_MIN) << "call OpenSession success,sid:" << sessionId;
361 SetCurrentSessionId4Data(sessionId);
362 ret = Wait4Session(5, SESSION_4DATA);
363 EXPECT_NE(SOFTBUS_OK, ret) << "Wait4Session success";
364 }
365
366 /**
367 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1500
368 * @tc.name : OpenSession Open the same one repeatedly
369 * @tc.desc : Test session management reliability
370 * @tc.type : RELI
371 * @tc.size : MediumTest
372 */
373 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1500, TestSize.Level3)
374 {
375 int ret;
376 int sessionId;
377 ret = CreateSsAndOpenSession4Data();
378 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
379 sessionId = GetCurrentSessionId4Data();
380
381 // open session repeat
382 int reSid;
383 ResetWaitFlag4Data();
384 reSid = OpenSession(SESSION_NAME_DATA, SESSION_NAME_DATA, GetNetworkId(), DEF_GROUP_ID, GetSessionAttr4Data());
385 EXPECT_EQ(sessionId, reSid) << "repeat open sid not match";
386
387 ret = CloseSessionAndRemoveSs4Data();
388 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
389 }
390
391 /**
392 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1600
393 * @tc.name : OpenSession input my name null
394 * @tc.desc : Test session management reliability
395 * @tc.type : RELI
396 * @tc.size : MediumTest
397 */
398 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1600, TestSize.Level3)
399 {
400 int ret;
401 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, GetSessionListenser4Data());
402 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSessionServer fail";
403
404 int sessionId;
405 sessionId = OpenSession(NULL, SESSION_NAME_DATA, GetNetworkId(), DEF_GROUP_ID, GetSessionAttr4Data());
406 EXPECT_TRUE(sessionId < SESSION_ID_MIN) << "call opensession success[my name null]";
407
408 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
409 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSessionServer fail";
410 }
411
412 /**
413 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1700
414 * @tc.name : OpenSession input peer name null
415 * @tc.desc : Test session management reliability
416 * @tc.type : RELI
417 * @tc.size : MediumTest
418 */
419 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1700, TestSize.Level3)
420 {
421 int ret;
422 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, GetSessionListenser4Data());
423 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSessionServer fail";
424
425 int sessionId;
426 sessionId = OpenSession(SESSION_NAME_DATA, NULL, GetNetworkId(), DEF_GROUP_ID, GetSessionAttr4Data());
427 EXPECT_TRUE(sessionId < SESSION_ID_MIN) << "call opensession success[peer name null]";
428
429 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
430 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSessionServer fail";
431 }
432
433 /**
434 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1800
435 * @tc.name : OpenSession input net id null
436 * @tc.desc : Test session management reliability
437 * @tc.type : RELI
438 * @tc.size : MediumTest
439 */
440 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1800, TestSize.Level3)
441 {
442 int ret;
443 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, GetSessionListenser4Data());
444 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSessionServer fail";
445
446 int sessionId;
447 sessionId = OpenSession(SESSION_NAME_DATA, SESSION_NAME_DATA, NULL, DEF_GROUP_ID, GetSessionAttr4Data());
448 EXPECT_TRUE(sessionId < SESSION_ID_MIN) << "call opensession success[net id null]";
449
450 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
451 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSessionServer fail";
452 }
453
454 /**
455 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1900
456 * @tc.name : OpenSession input net id invalid
457 * @tc.desc : Test session management reliability
458 * @tc.type : RELI
459 * @tc.size : MediumTest
460 */
461 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1900, TestSize.Level3)
462 {
463 int ret;
464 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, GetSessionListenser4Data());
465 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSessionServer fail";
466
467 int sessionId;
468 string invalidNetId = "123456789012345678901234567890123456789012345678901234567890abcd";
469 sessionId =
470 OpenSession(SESSION_NAME_DATA, SESSION_NAME_DATA, invalidNetId.c_str(), DEF_GROUP_ID, GetSessionAttr4Data());
471 EXPECT_TRUE(sessionId < SESSION_ID_MIN) << "call opensession success[net id invalid]";
472
473 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
474 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSessionServer fail";
475 }
476
477 /**
478 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2000
479 * @tc.name : OpenSession input group id null
480 * @tc.desc : Test session management reliability
481 * @tc.type : RELI
482 * @tc.size : MediumTest
483 */
484 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2000, TestSize.Level3)
485 {
486 int ret;
487 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, GetSessionListenser4Data());
488 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSessionServer fail";
489
490 int sessionId;
491 sessionId = OpenSession(SESSION_NAME_DATA, SESSION_NAME_DATA, GetNetworkId(), NULL, GetSessionAttr4Data());
492 EXPECT_TRUE(sessionId < SESSION_ID_MIN) << "call opensession success[group id null]";
493
494 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
495 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSessionServer fail";
496 }
497
498 /**
499 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2100
500 * @tc.name : OpenSession input arrt null
501 * @tc.desc : Test session management reliability
502 * @tc.type : RELI
503 * @tc.size : MediumTest
504 */
505 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2100, TestSize.Level3)
506 {
507 int ret;
508 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, GetSessionListenser4Data());
509 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSessionServer fail";
510
511 int sessionId;
512 sessionId = OpenSession(SESSION_NAME_DATA, SESSION_NAME_DATA, GetNetworkId(), DEF_GROUP_ID, NULL);
513 EXPECT_TRUE(sessionId < SESSION_ID_MIN) << "call opensession success[arrt null]";
514
515 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
516 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSessionServer fail";
517 }
518
519 /**
520 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2200
521 * @tc.name : OpenSession input arrt invalid
522 * @tc.desc : Test session management reliability
523 * @tc.type : RELI
524 * @tc.size : MediumTest
525 */
526 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2200, TestSize.Level3)
527 {
528 int ret;
529 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, GetSessionListenser4Data());
530 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSessionServer fail";
531
532 int sessionId;
533 SessionAttribute sAttr;
534 sAttr.dataType = 50;
535 sessionId = OpenSession(SESSION_NAME_DATA, SESSION_NAME_DATA, GetNetworkId(), DEF_GROUP_ID, &sAttr);
536 EXPECT_TRUE(sessionId < SESSION_ID_MIN) << "call opensession success[arrt invalid]";
537
538 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
539 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSessionServer fail";
540 }
541
542 /**
543 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2300
544 * @tc.name : CloseSession repeatedly
545 * @tc.desc : Test session management reliability
546 * @tc.type : RELI
547 * @tc.size : MediumTest
548 */
549 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2300, TestSize.Level3)
550 {
551 int ret;
552 int sessionId;
553 char* softbusPidStart;
554 char* softbusPidEnd;
555 softbusPidStart = GetSoftbusPid();
556 EXPECT_TRUE(softbusPidStart != NULL);
557
558 ret = CreateSsAndOpenSession4Data();
559 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
560 sessionId = GetCurrentSessionId4Data();
561
562 ResetWaitFlag4Data();
563 CloseSession(sessionId);
564 ret = Wait4Session(3, SESSION_4DATA);
565 EXPECT_NE(SOFTBUS_OK, ret) << "CloseSession(first) hit callback, expect not";
566
567 // repeat,expect fail
568 ResetWaitFlag4Data();
569 CloseSession(sessionId);
570 ret = Wait4Session(3, SESSION_4DATA);
571 EXPECT_NE(SOFTBUS_OK, ret) << "CloseSession(repeat) hit callback, expect not";
572
573 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
574 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSessionServer fail";
575
576 softbusPidEnd = GetSoftbusPid();
577 EXPECT_TRUE(softbusPidEnd != NULL);
578 EXPECT_STREQ(softbusPidStart, softbusPidEnd);
579 free(softbusPidStart);
580 free(softbusPidEnd);
581 }
582
583 /**
584 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2400
585 * @tc.name : CloseSession not exist sessionId
586 * @tc.desc : Test session management reliability
587 * @tc.type : RELI
588 * @tc.size : MediumTest
589 */
590 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2400, TestSize.Level3)
591 {
592 int ret;
593 int timeout = 3;
594 int sessionId = MAX_SESSION_NUM + 1;
595 ResetWaitFlag4Data();
596 CloseSession(sessionId);
597 ret = Wait4Session(timeout, SESSION_4DATA);
598 EXPECT_NE(SOFTBUS_OK, ret) << "CloseSession[sid > max] success";
599
600 sessionId = -1;
601 ResetWaitFlag4Data();
602 CloseSession(sessionId);
603 ret = Wait4Session(timeout, SESSION_4DATA);
604 EXPECT_NE(SOFTBUS_OK, ret) << "CloseSession[sid < 0] success";
605
606 sessionId = 10;
607 ResetWaitFlag4Data();
608 CloseSession(sessionId);
609 ret = Wait4Session(timeout, SESSION_4DATA);
610 EXPECT_NE(SOFTBUS_OK, ret) << "CloseSession[sid not open] success";
611 }
612
613 /**
614 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2500
615 * @tc.name : GetMySessionName input invalid sid -1
616 * @tc.desc : Test session management reliability
617 * @tc.type : RELI
618 * @tc.size : MediumTest
619 */
620 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2500, TestSize.Level3)
621 {
622 int ret;
623 int sessionId;
624 ret = CreateSsAndOpenSession4Data();
625 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
626 sessionId = GetCurrentSessionId4Data();
627
628 char mySname[SESSION_NAME_SIZE_MAX] = { 0 };
629 ret = GetMySessionName(-1, mySname, SESSION_NAME_SIZE_MAX);
630 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "GetMySessionName invalid sid[-1]";
631
632 ret = CloseSessionAndRemoveSs4Data();
633 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
634 }
635
636 /**
637 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2600
638 * @tc.name : GetMySessionName input invalid sid max+1
639 * @tc.desc : Test session management reliability
640 * @tc.type : RELI
641 * @tc.size : MediumTest
642 */
643 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2600, TestSize.Level3)
644 {
645 int ret;
646 int sessionId;
647 ret = CreateSsAndOpenSession4Data();
648 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
649 sessionId = GetCurrentSessionId4Data();
650
651 char mySname[SESSION_NAME_SIZE_MAX] = { 0 };
652 ret = GetMySessionName(MAX_SESSION_NUM + 1, mySname, SESSION_NAME_SIZE_MAX);
653 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret) << "GetMySessionName invalid sid[max+1]";
654
655 ret = CloseSessionAndRemoveSs4Data();
656 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
657 }
658
659 /**
660 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2700
661 * @tc.name : GetMySessionName input invalid sid not open
662 * @tc.desc : Test session management reliability
663 * @tc.type : RELI
664 * @tc.size : MediumTest
665 */
666 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2700, TestSize.Level3)
667 {
668 int ret;
669 int sessionId;
670 ret = CreateSsAndOpenSession4Data();
671 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
672 sessionId = GetCurrentSessionId4Data();
673
674 char mySname[SESSION_NAME_SIZE_MAX] = { 0 };
675 ret = GetMySessionName(sessionId + 1, mySname, SESSION_NAME_SIZE_MAX);
676 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret) << "GetMySessionName invalid sid[not open]";
677
678 ret = CloseSessionAndRemoveSs4Data();
679 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
680 }
681
682 /**
683 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2800
684 * @tc.name : GetMySessionName input MySessionName invalid sname null
685 * @tc.desc : Test session management reliability
686 * @tc.type : RELI
687 * @tc.size : MediumTest
688 */
689 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2800, TestSize.Level3)
690 {
691 int ret;
692 int sessionId;
693 ret = CreateSsAndOpenSession4Data();
694 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
695 sessionId = GetCurrentSessionId4Data();
696
697 ret = GetMySessionName(sessionId, NULL, SESSION_NAME_SIZE_MAX);
698 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "GetMySessionName invalid sname[null]";
699
700 ret = CloseSessionAndRemoveSs4Data();
701 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
702 }
703
704 /**
705 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2900
706 * @tc.name : GetMySessionName input MySessionName invalid len[max+1]
707 * @tc.desc : Test session management reliability
708 * @tc.type : RELI
709 * @tc.size : MediumTest
710 */
711 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2900, TestSize.Level3)
712 {
713 int ret;
714 int sessionId;
715 ret = CreateSsAndOpenSession4Data();
716 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
717 sessionId = GetCurrentSessionId4Data();
718
719 char mySname[SESSION_NAME_SIZE_MAX] = { 0 };
720 ret = GetMySessionName(sessionId, mySname, SESSION_NAME_SIZE_MAX + 1);
721 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "GetMySessionName invalid len[max+1]";
722
723 ret = CloseSessionAndRemoveSs4Data();
724 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
725 }
726
727 /**
728 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3000
729 * @tc.name : GetMySessionName input MySessionName len short than real
730 * @tc.desc : Test session management reliability
731 * @tc.type : RELI
732 * @tc.size : MediumTest
733 */
734 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3000, TestSize.Level3)
735 {
736 int ret;
737 int sessionId;
738 ret = CreateSsAndOpenSession4Data();
739 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
740 sessionId = GetCurrentSessionId4Data();
741 char mySnameShort[5];
742 ret = GetMySessionName(sessionId, mySnameShort, 5);
743 EXPECT_NE(SOFTBUS_OK, ret) << "GetMySessionName len short than real";
744
745 ret = CloseSessionAndRemoveSs4Data();
746 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
747 }
748
749 /**
750 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3100
751 * @tc.name : GetPeersessionName input invalid sid -1
752 * @tc.desc : Test session management reliability
753 * @tc.type : RELI
754 * @tc.size : MediumTest
755 */
756 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3100, TestSize.Level3)
757 {
758 int ret;
759 int sessionId;
760 ret = CreateSsAndOpenSession4Data();
761 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
762 sessionId = GetCurrentSessionId4Data();
763
764 char peerSname[SESSION_NAME_SIZE_MAX] = { 0 };
765 ret = GetPeerSessionName(-1, peerSname, SESSION_NAME_SIZE_MAX);
766 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "GetPeerSessionName invalid sid[-1]";
767
768 ret = CloseSessionAndRemoveSs4Data();
769 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
770 }
771
772 /**
773 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3200
774 * @tc.name : GetPeersessionName input invalid sid max+1
775 * @tc.desc : Test session management reliability
776 * @tc.type : RELI
777 * @tc.size : MediumTest
778 */
779 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3200, TestSize.Level3)
780 {
781 int ret;
782 int sessionId;
783 ret = CreateSsAndOpenSession4Data();
784 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
785 sessionId = GetCurrentSessionId4Data();
786
787 char peerSname[SESSION_NAME_SIZE_MAX] = { 0 };
788 ret = GetPeerSessionName(MAX_SESSION_NUM + 1, peerSname, SESSION_NAME_SIZE_MAX);
789 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret) << "GetPeerSessionName invalid sid[max+1]";
790
791 ret = CloseSessionAndRemoveSs4Data();
792 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
793 }
794
795 /**
796 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3300
797 * @tc.name : GetPeersessionName input invalid sid not open
798 * @tc.desc : Test session management reliability
799 * @tc.type : RELI
800 * @tc.size : MediumTest
801 */
802 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3300, TestSize.Level3)
803 {
804 int ret;
805 int sessionId;
806 ret = CreateSsAndOpenSession4Data();
807 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
808 sessionId = GetCurrentSessionId4Data();
809
810 char peerSname[SESSION_NAME_SIZE_MAX] = { 0 };
811 ret = GetPeerSessionName(sessionId + 1, peerSname, SESSION_NAME_SIZE_MAX);
812 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret) << "GetPeerSessionName invalid sid[not open]";
813
814 ret = CloseSessionAndRemoveSs4Data();
815 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
816 }
817
818 /**
819 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3400
820 * @tc.name : GetPeersessionName input SessionName invalid sname[null]
821 * @tc.desc : Test session management reliability
822 * @tc.type : RELI
823 * @tc.size : MediumTest
824 */
825 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3400, TestSize.Level3)
826 {
827 int ret;
828 int sessionId;
829 ret = CreateSsAndOpenSession4Data();
830 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
831 sessionId = GetCurrentSessionId4Data();
832
833 ret = GetPeerSessionName(sessionId, NULL, SESSION_NAME_SIZE_MAX);
834 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "GetPeerSessionName invalid sname[null]";
835
836 ret = CloseSessionAndRemoveSs4Data();
837 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
838 }
839
840 /**
841 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3500
842 * @tc.name : GetPeersessionName input PeerSessionName invalid len[max+1]
843 * @tc.desc : Test session management reliability
844 * @tc.type : RELI
845 * @tc.size : MediumTest
846 */
847 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3500, TestSize.Level3)
848 {
849 int ret;
850 int sessionId;
851 ret = CreateSsAndOpenSession4Data();
852 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
853 sessionId = GetCurrentSessionId4Data();
854
855 char peerSname[SESSION_NAME_SIZE_MAX] = { 0 };
856 ret = GetPeerSessionName(sessionId, peerSname, SESSION_NAME_SIZE_MAX + 1);
857 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "GetPeerSessionName invalid len[max+1]";
858
859 ret = CloseSessionAndRemoveSs4Data();
860 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
861 }
862
863 /**
864 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3600
865 * @tc.name : GetPeersessionName input PeerSessionName len short than real
866 * @tc.desc : Test session management reliability
867 * @tc.type : RELI
868 * @tc.size : MediumTest
869 */
870 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3600, TestSize.Level3)
871 {
872 int ret;
873 int sessionId;
874 ret = CreateSsAndOpenSession4Data();
875 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
876 sessionId = GetCurrentSessionId4Data();
877
878 char peerSnameShort[5];
879 ret = GetPeerSessionName(sessionId, peerSnameShort, 5);
880 EXPECT_NE(SOFTBUS_OK, ret) << "GetPeerSessionName len short than real";
881
882 ret = CloseSessionAndRemoveSs4Data();
883 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
884 }
885
886 /**
887 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3700
888 * @tc.name : GetPeerDeviceId input DeviceId invalid sid -1
889 * @tc.desc : 【G-DISTRIBUTED-0205】禁止修改Openharmony分布式软总线设备间传输通道管理协议。
890 * @tc.type : RELI
891 * @tc.size : MediumTest
892 */
893 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3700, TestSize.Level3)
894 {
895 int ret;
896 int sessionId;
897 ret = CreateSsAndOpenSession4Data();
898 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
899 sessionId = GetCurrentSessionId4Data();
900
901 char deviceId[SESSION_NAME_SIZE_MAX] = { 0 };
902 ret = GetPeerDeviceId(-1, deviceId, SESSION_NAME_SIZE_MAX);
903 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "GetPeerDeviceId invalid sid[-1]";
904
905 ret = CloseSessionAndRemoveSs4Data();
906 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
907 }
908
909 /**
910 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3800
911 * @tc.name : GetPeerDeviceId input DeviceId invalid sid[max+1]
912 * @tc.desc : Test session management reliability
913 * @tc.type : RELI
914 * @tc.size : MediumTest
915 */
916 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3800, TestSize.Level3)
917 {
918 int ret;
919 int sessionId;
920 ret = CreateSsAndOpenSession4Data();
921 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
922 sessionId = GetCurrentSessionId4Data();
923
924 char deviceId[SESSION_NAME_SIZE_MAX] = { 0 };
925 ret = GetPeerDeviceId(MAX_SESSION_NUM + 1, deviceId, SESSION_NAME_SIZE_MAX);
926 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret) << "GetPeerDeviceId invalid sid[max+1]";
927
928 ret = CloseSessionAndRemoveSs4Data();
929 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
930 }
931
932 /**
933 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3900
934 * @tc.name : GetPeerDeviceId input DeviceId invalid sid not open
935 * @tc.desc : 【G-DISTRIBUTED-0205】禁止修改Openharmony分布式软总线设备间传输通道管理协议。
936 * @tc.type : RELI
937 * @tc.size : MediumTest
938 */
939 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3900, TestSize.Level3)
940 {
941 int ret;
942 int sessionId;
943 ret = CreateSsAndOpenSession4Data();
944 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
945
946 char deviceId[SESSION_NAME_SIZE_MAX] = { 0 };
947 sessionId = GetCurrentSessionId4Data();
948 ret = GetPeerDeviceId(sessionId + 1, deviceId, SESSION_NAME_SIZE_MAX);
949 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret) << "GetPeerDeviceId invalid sid[not open]";
950 ret = CloseSessionAndRemoveSs4Data();
951 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
952 }
953
954 /**
955 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4000
956 * @tc.name : GetPeerDeviceId input DeviceId invalid sname[null]
957 * @tc.desc : 【G-DISTRIBUTED-0205】禁止修改Openharmony分布式软总线设备间传输通道管理协议。
958 * @tc.type : RELI
959 * @tc.size : MediumTest
960 */
961 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4000, TestSize.Level3)
962 {
963 int ret;
964 int sessionId;
965 ret = CreateSsAndOpenSession4Data();
966 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
967 sessionId = GetCurrentSessionId4Data();
968
969 ret = GetPeerDeviceId(sessionId, NULL, SESSION_NAME_SIZE_MAX);
970 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "GetPeerDeviceId invalid sname[null]";
971
972 ret = CloseSessionAndRemoveSs4Data();
973 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
974 }
975 /**
976 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4100
977 * @tc.name : GetPeerDeviceId input DeviceId invalid len[max+1]
978 * @tc.desc : Test session management reliability
979 * @tc.type : RELI
980 * @tc.size : MediumTest
981 */
982 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4100, TestSize.Level3)
983 {
984 int ret;
985 int sessionId;
986 ret = CreateSsAndOpenSession4Data();
987 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
988 sessionId = GetCurrentSessionId4Data();
989
990 char deviceId[SESSION_NAME_SIZE_MAX] = { 0 };
991 ret = GetPeerDeviceId(sessionId, deviceId, SESSION_NAME_SIZE_MAX + 1);
992 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "GetPeerDeviceId invalid len[max+1]";
993
994 ret = CloseSessionAndRemoveSs4Data();
995 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
996 }
997 /**
998 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4200
999 * @tc.name : GetPeerDeviceId input DeviceId len short than real
1000 * @tc.desc : Test session management reliability
1001 * @tc.type : RELI
1002 * @tc.size : MediumTest
1003 */
1004 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4200, TestSize.Level3)
1005 {
1006 int ret;
1007 int sessionId;
1008 ret = CreateSsAndOpenSession4Data();
1009 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
1010 sessionId = GetCurrentSessionId4Data();
1011
1012 char deviceIdShort[5];
1013 ret = GetPeerDeviceId(sessionId, deviceIdShort, 5);
1014 EXPECT_NE(SOFTBUS_OK, ret) << "GetPeerDeviceId len short than real";
1015
1016 ret = CloseSessionAndRemoveSs4Data();
1017 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
1018 }
1019
1020 /**
1021 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4300
1022 * @tc.name : OpenSession, no Session Server exists on the peer
1023 * @tc.desc : Test session management reliability
1024 * @tc.type : RELI
1025 * @tc.size : MediumTest
1026 */
1027 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4300, TestSize.Level3)
1028 {
1029 int ret;
1030 char* softbusPidStart;
1031 char* softbusPidEnd;
1032 softbusPidStart = GetSoftbusPid();
1033 EXPECT_TRUE(softbusPidStart != NULL);
1034
1035 int sessionId;
1036 string notExistSession = "Not Exist Session Name";
1037 ret = CreateSessionServer(DEF_PKG_NAME, notExistSession.c_str(), GetSessionListenser4Ctl());
1038 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret) << "CreateSS-ctrl fail";
1039 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, GetSessionListenser4Data());
1040 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS-data fail";
1041
1042 ResetWaitFlag4Data();
1043 sessionId =
1044 OpenSession(SESSION_NAME_DATA, notExistSession.c_str(), GetNetworkId(), DEF_GROUP_ID, GetSessionAttr4Data());
1045 EXPECT_TRUE(sessionId < SESSION_ID_MIN) << "call open session fail, expect success";
1046 ret = Wait4Session(OPEN_SESSION_TIMEOUT, SESSION_4DATA);
1047 EXPECT_NE(SOFTBUS_OK, ret) << "wait session cb success, expect fail";
1048
1049 int timeout = 5;
1050 ResetWaitFlag4Data();
1051 sessionId = OpenSession(SESSION_NAME_DATA, SESSION_NAME_DATA, GetNetworkId(), DEF_GROUP_ID, GetSessionAttr4Data());
1052 SetCurrentSessionId4Data(sessionId);
1053 EXPECT_TRUE(sessionId >= SESSION_ID_MIN) << "OpenSession normal[data] fail, expect success";
1054 ret = Wait4Session(timeout, SESSION_4DATA);
1055 EXPECT_EQ(SOFTBUS_OK, ret) << "wait session cb fail, expect success";
1056
1057 // clean
1058 CloseSession(sessionId);
1059 ret = RemoveSessionServer(DEF_PKG_NAME, notExistSession.c_str());
1060 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret) << "RemoveSS-notExist fail";
1061 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
1062 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS-data fail";
1063 sleep(timeout);
1064
1065 softbusPidEnd = GetSoftbusPid();
1066 EXPECT_TRUE(softbusPidEnd != NULL);
1067 EXPECT_STREQ(softbusPidStart, softbusPidEnd);
1068 free(softbusPidStart);
1069 free(softbusPidEnd);
1070 }
1071
1072 /**
1073 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4400
1074 * @tc.name : CreateSessionServer, input sessionName Max success
1075 * @tc.desc : Test session management reliability
1076 * @tc.type : RELI
1077 * @tc.size : MediumTest
1078 */
1079 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4400, TestSize.Level3)
1080 {
1081 int ret = CreateSessionServer(DEF_PKG_NAME, SESSIONNAME_MAX, GetSessionListenser4Ctl());
1082 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS-ctrl fail";
1083 ret = RemoveSessionServer(DEF_PKG_NAME, SESSIONNAME_MAX);
1084 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS-ctrl fail";
1085 }
1086
1087 /**
1088 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4500
1089 * @tc.name : CreateSessionServer, input sessionName contains special char
1090 * @tc.desc : Test session management reliability
1091 * @tc.type : RELI
1092 * @tc.size : MediumTest
1093 */
1094 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4500, TestSize.Level3)
1095 {
1096 string sessionName = "com.communication.demo.max.len.#@$%!";
1097 int ret = CreateSessionServer(DEF_PKG_NAME, sessionName.c_str(), GetSessionListenser4Ctl());
1098 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS-ctrl fail";
1099 ret = RemoveSessionServer(DEF_PKG_NAME, sessionName.c_str());
1100 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS-ctrl fail";
1101 }
1102
1103 /**
1104 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4600
1105 * @tc.name : CreateSessionServer, input pkgName Max success
1106 * @tc.desc : Test session management reliability
1107 * @tc.type : RELI
1108 * @tc.size : MediumTest
1109 */
1110 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4600, TestSize.Level3)
1111 {
1112 int ret = CreateSessionServer(PKGNAME_MAX, SESSION_NAME_CTL, GetSessionListenser4Ctl());
1113 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS-ctrl fail";
1114 ret = RemoveSessionServer(PKGNAME_MAX, SESSION_NAME_CTL);
1115 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS-ctrl fail";
1116 }
1117
1118 /**
1119 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4700
1120 * @tc.name : CreateSessionServer, input pkgNameMax and sessionNameMax
1121 * @tc.desc : 【G-DISTRIBUTED-0205】禁止修改Openharmony分布式软总线设备间传输通道管理协议。
1122 * @tc.type : RELI
1123 * @tc.size : MediumTest
1124 */
1125 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4700, TestSize.Level3)
1126 {
1127 int ret = CreateSessionServer(PKGNAME_MAX, SESSIONNAME_MAX, GetSessionListenser4Ctl());
1128 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS-ctrl fail, pkgnamelen:"
1129 << strlen(PKGNAME_MAX) << ",sessionLen:" << strlen(SESSIONNAME_MAX);
1130 ret = RemoveSessionServer(PKGNAME_MAX, SESSIONNAME_MAX);
1131 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS-ctrl fail";
1132 }
1133
1134 /**
1135 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4800
1136 * @tc.name : CreateSessionServer, input pkgName Max+1 failed
1137 * @tc.desc : 【G-DISTRIBUTED-0205】禁止修改Openharmony分布式软总线设备间传输通道管理协议。
1138 * @tc.type : RELI
1139 * @tc.size : MediumTest
1140 */
1141 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4800, TestSize.Level3)
1142 {
1143 int ret = CreateSessionServer(PKGNAME_MAX_OUT, SESSION_NAME_CTL, GetSessionListenser4Ctl());
1144 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret) << "CreateSS-ctrl success";
1145 ret = RemoveSessionServer(PKGNAME_MAX_OUT, SESSION_NAME_CTL);
1146 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret) << "RemoveSS-ctrl fail";
1147 }
1148
1149 /**
1150 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4900
1151 * @tc.name : CreateSessionServer, input sessionName Max+1 failed
1152 * @tc.desc : 【G-DISTRIBUTED-0205】禁止修改Openharmony分布式软总线设备间传输通道管理协议。
1153 * @tc.type : RELI
1154 * @tc.size : MediumTest
1155 */
1156 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4900, TestSize.Level3)
1157 {
1158 int ret = CreateSessionServer(DEF_PKG_NAME, SESSIONNAME_MAX_OUT, GetSessionListenser4Ctl());
1159 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret) << "CreateSS-ctrl success";
1160 ret = RemoveSessionServer(DEF_PKG_NAME, SESSIONNAME_MAX_OUT);
1161 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret) << "RemoveSS-ctrl success";
1162 }
1163
1164 /**
1165 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_5000
1166 * @tc.name : CreateSessionServer, input pkgName contains special char
1167 * @tc.desc : 【G-DISTRIBUTED-0205】禁止修改Openharmony分布式软总线设备间传输通道管理协议。
1168 * @tc.type : RELI
1169 * @tc.size : MediumTest
1170 */
1171 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_5000, TestSize.Level3)
1172 {
1173 int ret = CreateSessionServer(DEF_PKG_NAME, SESSIONNAME_MAX, GetSessionListenser4Ctl());
1174 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS-ctrl fail";
1175 ret = RemoveSessionServer(DEF_PKG_NAME, SESSIONNAME_MAX);
1176 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS-ctrl fail";
1177 ret = CreateSessionServer(PKGNAME_MAX, SESSIONNAME_MAX, GetSessionListenser4Ctl());
1178 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS-ctrl fail";
1179 ret = RemoveSessionServer(PKGNAME_MAX, SESSIONNAME_MAX);
1180 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS-ctrl fail";
1181 string pkgName = "com.communication.demo.max.len.#@$%!";
1182 ret = CreateSessionServer(pkgName.c_str(), SESSION_NAME_DATA, GetSessionListenser4Data());
1183 EXPECT_EQ(SOFTBUS_INVALID_PKGNAME, ret) << "CreateSS-ctrl success";
1184 ret = RemoveSessionServer(pkgName.c_str(), SESSION_NAME_DATA);
1185 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS-ctrl success";
1186 }
1187
1188 /**
1189 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_5100
1190 * @tc.name : CreateSessionServer, input invalid sessionName failed
1191 * @tc.desc : 【G-DISTRIBUTED-0211】出于安全和兼容性考虑，不应修改安全相关逻辑，不应变更软总线依赖的安全和协议部件。
1192 * @tc.type : RELI
1193 * @tc.size : MediumTest
1194 */
1195 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_5100, TestSize.Level3)
1196 {
1197 string sessionName = "com.communication.test.demo";
1198 int ret = CreateSessionServer(DEF_PKG_NAME, sessionName.c_str(), GetSessionListenser4Ctl());
1199 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret) << "CreateSS-ctrl success";
1200 ret = RemoveSessionServer(DEF_PKG_NAME, sessionName.c_str());
1201 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret) << "RemoveSS-ctrl fail";
1202 }
1203
1204 /**
1205 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_5200
1206 * @tc.name : GetNodeKeyInfoTestCase
1207 * @tc.desc : GetNodeKeyInfo Performance Testing
1208 * @tc.type : RELI
1209 * @tc.size : MediumTest
1210 */
1211
1212 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_GetNodeKey_Reli_5200, TestSize.Level3)
1213 {
1214 int ret;
1215 NodeBasicInfo info;
1216 char udid[UDID_BUF_LEN] = {0};
1217 (void)memset_s(&info, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
1218 GetLocalNodeDeviceInfo(DEF_PKG_NAME, &info);
1219 ret = GetNodeKeyInfo(DEF_PKG_NAME, info.networkId, NODE_KEY_UDID,
1220 (uint8_t *)udid, UDID_BUF_LEN);
1221 EXPECT_EQ(0, ret) << "GetNodeKeyInfoTestCase failed.";
1222 }