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 /**
305 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1100
306 * @tc.name : RemoveSessionServer input pkg name null
307 * @tc.desc : Test session management reliability
308 * @tc.type : RELI
309 * @tc.size : MediumTest
310 */
311 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1100, TestSize.Level3)
312 {
313 int ret;
314 ret = RemoveSessionServer(NULL, SESSION_NAME_DATA);
315 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret) << "RemoveSS success[pkg name null]";
316
317 }
318
319 /**
320 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1200
321 * @tc.name : RemoveSessionServer input session name null
322 * @tc.desc : Test session management reliability
323 * @tc.type : RELI
324 * @tc.size : MediumTest
325 */
326 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1200, TestSize.Level3)
327 {
328 int ret;
329
330 ret = RemoveSessionServer(DEF_PKG_NAME, NULL);
331 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret) << "RemoveSS success[session name null]";
332 }
333
334 /**
335 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1300
336 * @tc.name : RemoveSessionServer input all null
337 * @tc.desc : Test session management reliability
338 * @tc.type : RELI
339 * @tc.size : MediumTest
340 */
341 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1300, TestSize.Level3)
342 {
343 int ret;
344 ret = RemoveSessionServer(NULL, NULL);
345 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret) << "RemoveSS success[all null]";
346 }
347
348 /**
349 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1400
350 * @tc.name : OpenSession, SessionServer do not exist
351 * @tc.desc : Test session management reliability
352 * @tc.type : RELI
353 * @tc.size : MediumTest
354 */
355 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1400, TestSize.Level3)
356 {
357 int ret;
358 int sessionId;
359 ResetWaitFlag4Data();
360 sessionId = OpenSession(SESSION_NAME_DATA, SESSION_NAME_DATA, GetNetworkId(), DEF_GROUP_ID, GetSessionAttr4Data());
361 EXPECT_TRUE(sessionId < SESSION_ID_MIN) << "call OpenSession success,sid:" << sessionId;
362 SetCurrentSessionId4Data(sessionId);
363 ret = Wait4Session(5, SESSION_4DATA);
364 EXPECT_NE(SOFTBUS_OK, ret) << "Wait4Session success";
365 }
366
367 /**
368 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1500
369 * @tc.name : OpenSession Open the same one repeatedly
370 * @tc.desc : Test session management reliability
371 * @tc.type : RELI
372 * @tc.size : MediumTest
373 */
374 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1500, TestSize.Level3)
375 {
376 int ret;
377 int sessionId;
378 ret = CreateSsAndOpenSession4Data();
379 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
380 sessionId = GetCurrentSessionId4Data();
381
382 // open session repeat
383 int reSid;
384 ResetWaitFlag4Data();
385 reSid = OpenSession(SESSION_NAME_DATA, SESSION_NAME_DATA, GetNetworkId(), DEF_GROUP_ID, GetSessionAttr4Data());
386 EXPECT_EQ(sessionId, reSid) << "repeat open sid not match";
387
388 ret = CloseSessionAndRemoveSs4Data();
389 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
390 }
391
392 /**
393 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1600
394 * @tc.name : OpenSession input my name null
395 * @tc.desc : Test session management reliability
396 * @tc.type : RELI
397 * @tc.size : MediumTest
398 */
399 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1600, TestSize.Level3)
400 {
401 int ret;
402 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, GetSessionListenser4Data());
403 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSessionServer fail";
404
405 int sessionId;
406 sessionId = OpenSession(NULL, SESSION_NAME_DATA, GetNetworkId(), DEF_GROUP_ID, GetSessionAttr4Data());
407 EXPECT_TRUE(sessionId < SESSION_ID_MIN) << "call opensession success[my name null]";
408
409 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
410 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSessionServer fail";
411 }
412
413 /**
414 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1700
415 * @tc.name : OpenSession input peer name null
416 * @tc.desc : Test session management reliability
417 * @tc.type : RELI
418 * @tc.size : MediumTest
419 */
420 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1700, TestSize.Level3)
421 {
422 int ret;
423 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, GetSessionListenser4Data());
424 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSessionServer fail";
425
426 int sessionId;
427 sessionId = OpenSession(SESSION_NAME_DATA, NULL, GetNetworkId(), DEF_GROUP_ID, GetSessionAttr4Data());
428 EXPECT_TRUE(sessionId < SESSION_ID_MIN) << "call opensession success[peer name null]";
429
430 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
431 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSessionServer fail";
432 }
433
434 /**
435 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1800
436 * @tc.name : OpenSession input net id null
437 * @tc.desc : Test session management reliability
438 * @tc.type : RELI
439 * @tc.size : MediumTest
440 */
441 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1800, TestSize.Level3)
442 {
443 int ret;
444 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, GetSessionListenser4Data());
445 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSessionServer fail";
446
447 int sessionId;
448 sessionId = OpenSession(SESSION_NAME_DATA, SESSION_NAME_DATA, NULL, DEF_GROUP_ID, GetSessionAttr4Data());
449 EXPECT_TRUE(sessionId < SESSION_ID_MIN) << "call opensession success[net id null]";
450
451 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
452 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSessionServer fail";
453 }
454
455 /**
456 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_1900
457 * @tc.name : OpenSession input net id invalid
458 * @tc.desc : Test session management reliability
459 * @tc.type : RELI
460 * @tc.size : MediumTest
461 */
462 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_1900, TestSize.Level3)
463 {
464 int ret;
465 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, GetSessionListenser4Data());
466 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSessionServer fail";
467
468 int sessionId;
469 string invalidNetId = "123456789012345678901234567890123456789012345678901234567890abcd";
470 sessionId =
471 OpenSession(SESSION_NAME_DATA, SESSION_NAME_DATA, invalidNetId.c_str(), DEF_GROUP_ID, GetSessionAttr4Data());
472 EXPECT_TRUE(sessionId < SESSION_ID_MIN) << "call opensession success[net id invalid]";
473
474 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
475 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSessionServer fail";
476 }
477
478 /**
479 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2000
480 * @tc.name : OpenSession input group id null
481 * @tc.desc : Test session management reliability
482 * @tc.type : RELI
483 * @tc.size : MediumTest
484 */
485 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2000, TestSize.Level3)
486 {
487 int ret;
488 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, GetSessionListenser4Data());
489 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSessionServer fail";
490
491 int sessionId;
492 sessionId = OpenSession(SESSION_NAME_DATA, SESSION_NAME_DATA, GetNetworkId(), NULL, GetSessionAttr4Data());
493 EXPECT_TRUE(sessionId < SESSION_ID_MIN) << "call opensession success[group id null]";
494
495 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
496 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSessionServer fail";
497 }
498
499 /**
500 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2100
501 * @tc.name : OpenSession input arrt null
502 * @tc.desc : Test session management reliability
503 * @tc.type : RELI
504 * @tc.size : MediumTest
505 */
506 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2100, TestSize.Level3)
507 {
508 int ret;
509 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, GetSessionListenser4Data());
510 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSessionServer fail";
511
512 int sessionId;
513 sessionId = OpenSession(SESSION_NAME_DATA, SESSION_NAME_DATA, GetNetworkId(), DEF_GROUP_ID, NULL);
514 EXPECT_TRUE(sessionId < SESSION_ID_MIN) << "call opensession success[arrt null]";
515
516 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
517 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSessionServer fail";
518 }
519
520 /**
521 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2200
522 * @tc.name : OpenSession input arrt invalid
523 * @tc.desc : Test session management reliability
524 * @tc.type : RELI
525 * @tc.size : MediumTest
526 */
527 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2200, TestSize.Level3)
528 {
529 int ret;
530 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, GetSessionListenser4Data());
531 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSessionServer fail";
532
533 int sessionId;
534 SessionAttribute sAttr;
535 sAttr.dataType = 50;
536 sessionId = OpenSession(SESSION_NAME_DATA, SESSION_NAME_DATA, GetNetworkId(), DEF_GROUP_ID, &sAttr);
537 EXPECT_TRUE(sessionId < SESSION_ID_MIN) << "call opensession success[arrt invalid]";
538
539 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
540 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSessionServer fail";
541 }
542
543 /**
544 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2300
545 * @tc.name : CloseSession repeatedly
546 * @tc.desc : Test session management reliability
547 * @tc.type : RELI
548 * @tc.size : MediumTest
549 */
550 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2300, TestSize.Level3)
551 {
552 int ret;
553 int sessionId;
554 char* softbusPidStart;
555 char* softbusPidEnd;
556 softbusPidStart = GetSoftbusPid();
557 EXPECT_TRUE(softbusPidStart != NULL);
558
559 ret = CreateSsAndOpenSession4Data();
560 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
561 sessionId = GetCurrentSessionId4Data();
562
563 ResetWaitFlag4Data();
564 CloseSession(sessionId);
565 ret = Wait4Session(3, SESSION_4DATA);
566 EXPECT_NE(SOFTBUS_OK, ret) << "CloseSession(first) hit callback, expect not";
567
568 // repeat,expect fail
569 ResetWaitFlag4Data();
570 CloseSession(sessionId);
571 ret = Wait4Session(3, SESSION_4DATA);
572 EXPECT_NE(SOFTBUS_OK, ret) << "CloseSession(repeat) hit callback, expect not";
573
574 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
575 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSessionServer fail";
576
577 softbusPidEnd = GetSoftbusPid();
578 EXPECT_TRUE(softbusPidEnd != NULL);
579 EXPECT_STREQ(softbusPidStart, softbusPidEnd);
580 free(softbusPidStart);
581 free(softbusPidEnd);
582 }
583
584 /**
585 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2400
586 * @tc.name : CloseSession not exist sessionId
587 * @tc.desc : Test session management reliability
588 * @tc.type : RELI
589 * @tc.size : MediumTest
590 */
591 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2400, TestSize.Level3)
592 {
593 int ret;
594 int timeout = 3;
595 int sessionId = MAX_SESSION_NUM + 1;
596 ResetWaitFlag4Data();
597 CloseSession(sessionId);
598 ret = Wait4Session(timeout, SESSION_4DATA);
599 EXPECT_NE(SOFTBUS_OK, ret) << "CloseSession[sid > max] success";
600
601 sessionId = -1;
602 ResetWaitFlag4Data();
603 CloseSession(sessionId);
604 ret = Wait4Session(timeout, SESSION_4DATA);
605 EXPECT_NE(SOFTBUS_OK, ret) << "CloseSession[sid < 0] success";
606
607 sessionId = 10;
608 ResetWaitFlag4Data();
609 CloseSession(sessionId);
610 ret = Wait4Session(timeout, SESSION_4DATA);
611 EXPECT_NE(SOFTBUS_OK, ret) << "CloseSession[sid not open] success";
612 }
613
614 /**
615 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2500
616 * @tc.name : GetMySessionName input invalid sid -1
617 * @tc.desc : Test session management reliability
618 * @tc.type : RELI
619 * @tc.size : MediumTest
620 */
621 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2500, TestSize.Level3)
622 {
623 int ret;
624 int sessionId;
625 ret = CreateSsAndOpenSession4Data();
626 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
627 sessionId = GetCurrentSessionId4Data();
628
629 char mySname[SESSION_NAME_SIZE_MAX] = { 0 };
630 ret = GetMySessionName(-1, mySname, SESSION_NAME_SIZE_MAX);
631 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "GetMySessionName invalid sid[-1]";
632
633 ret = CloseSessionAndRemoveSs4Data();
634 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
635 }
636
637 /**
638 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2600
639 * @tc.name : GetMySessionName input invalid sid max+1
640 * @tc.desc : Test session management reliability
641 * @tc.type : RELI
642 * @tc.size : MediumTest
643 */
644 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2600, TestSize.Level3)
645 {
646 int ret;
647 int sessionId;
648 ret = CreateSsAndOpenSession4Data();
649 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
650 sessionId = GetCurrentSessionId4Data();
651
652 char mySname[SESSION_NAME_SIZE_MAX] = { 0 };
653 ret = GetMySessionName(MAX_SESSION_NUM + 1, mySname, SESSION_NAME_SIZE_MAX);
654 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret) << "GetMySessionName invalid sid[max+1]";
655
656 ret = CloseSessionAndRemoveSs4Data();
657 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
658 }
659
660 /**
661 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2700
662 * @tc.name : GetMySessionName input invalid sid not open
663 * @tc.desc : Test session management reliability
664 * @tc.type : RELI
665 * @tc.size : MediumTest
666 */
667 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2700, TestSize.Level3)
668 {
669 int ret;
670 int sessionId;
671 ret = CreateSsAndOpenSession4Data();
672 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
673 sessionId = GetCurrentSessionId4Data();
674
675 char mySname[SESSION_NAME_SIZE_MAX] = { 0 };
676 ret = GetMySessionName(sessionId + 1, mySname, SESSION_NAME_SIZE_MAX);
677 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret) << "GetMySessionName invalid sid[not open]";
678
679 ret = CloseSessionAndRemoveSs4Data();
680 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
681 }
682
683 /**
684 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2800
685 * @tc.name : GetMySessionName input MySessionName invalid sname null
686 * @tc.desc : Test session management reliability
687 * @tc.type : RELI
688 * @tc.size : MediumTest
689 */
690 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2800, TestSize.Level3)
691 {
692 int ret;
693 int sessionId;
694 ret = CreateSsAndOpenSession4Data();
695 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
696 sessionId = GetCurrentSessionId4Data();
697
698 ret = GetMySessionName(sessionId, NULL, SESSION_NAME_SIZE_MAX);
699 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "GetMySessionName invalid sname[null]";
700
701 ret = CloseSessionAndRemoveSs4Data();
702 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
703 }
704
705 /**
706 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_2900
707 * @tc.name : GetMySessionName input MySessionName invalid len[max+1]
708 * @tc.desc : Test session management reliability
709 * @tc.type : RELI
710 * @tc.size : MediumTest
711 */
712 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_2900, TestSize.Level3)
713 {
714 int ret;
715 int sessionId;
716 ret = CreateSsAndOpenSession4Data();
717 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
718 sessionId = GetCurrentSessionId4Data();
719
720 char mySname[SESSION_NAME_SIZE_MAX] = { 0 };
721 ret = GetMySessionName(sessionId, mySname, SESSION_NAME_SIZE_MAX + 1);
722 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "GetMySessionName invalid len[max+1]";
723
724 ret = CloseSessionAndRemoveSs4Data();
725 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
726 }
727
728 /**
729 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3000
730 * @tc.name : GetMySessionName input MySessionName len short than real
731 * @tc.desc : Test session management reliability
732 * @tc.type : RELI
733 * @tc.size : MediumTest
734 */
735 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3000, TestSize.Level3)
736 {
737 int ret;
738 int sessionId;
739 ret = CreateSsAndOpenSession4Data();
740 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
741 sessionId = GetCurrentSessionId4Data();
742 char mySnameShort[5];
743 ret = GetMySessionName(sessionId, mySnameShort, 5);
744 EXPECT_NE(SOFTBUS_OK, ret) << "GetMySessionName len short than real";
745
746 ret = CloseSessionAndRemoveSs4Data();
747 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
748 }
749
750 /**
751 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3100
752 * @tc.name : GetPeersessionName input invalid sid -1
753 * @tc.desc : Test session management reliability
754 * @tc.type : RELI
755 * @tc.size : MediumTest
756 */
757 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3100, TestSize.Level3)
758 {
759 int ret;
760 int sessionId;
761 ret = CreateSsAndOpenSession4Data();
762 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
763 sessionId = GetCurrentSessionId4Data();
764
765 char peerSname[SESSION_NAME_SIZE_MAX] = { 0 };
766 ret = GetPeerSessionName(-1, peerSname, SESSION_NAME_SIZE_MAX);
767 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "GetPeerSessionName invalid sid[-1]";
768
769 ret = CloseSessionAndRemoveSs4Data();
770 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
771 }
772
773 /**
774 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3200
775 * @tc.name : GetPeersessionName input invalid sid max+1
776 * @tc.desc : Test session management reliability
777 * @tc.type : RELI
778 * @tc.size : MediumTest
779 */
780 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3200, TestSize.Level3)
781 {
782 int ret;
783 int sessionId;
784 ret = CreateSsAndOpenSession4Data();
785 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
786 sessionId = GetCurrentSessionId4Data();
787
788 char peerSname[SESSION_NAME_SIZE_MAX] = { 0 };
789 ret = GetPeerSessionName(MAX_SESSION_NUM + 1, peerSname, SESSION_NAME_SIZE_MAX);
790 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret) << "GetPeerSessionName invalid sid[max+1]";
791
792 ret = CloseSessionAndRemoveSs4Data();
793 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
794 }
795
796 /**
797 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3300
798 * @tc.name : GetPeersessionName input invalid sid not open
799 * @tc.desc : Test session management reliability
800 * @tc.type : RELI
801 * @tc.size : MediumTest
802 */
803 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3300, TestSize.Level3)
804 {
805 int ret;
806 int sessionId;
807 ret = CreateSsAndOpenSession4Data();
808 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
809 sessionId = GetCurrentSessionId4Data();
810
811 char peerSname[SESSION_NAME_SIZE_MAX] = { 0 };
812 ret = GetPeerSessionName(sessionId + 1, peerSname, SESSION_NAME_SIZE_MAX);
813 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret) << "GetPeerSessionName invalid sid[not open]";
814
815 ret = CloseSessionAndRemoveSs4Data();
816 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
817 }
818
819 /**
820 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3400
821 * @tc.name : GetPeersessionName input SessionName invalid sname[null]
822 * @tc.desc : Test session management reliability
823 * @tc.type : RELI
824 * @tc.size : MediumTest
825 */
826 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3400, TestSize.Level3)
827 {
828 int ret;
829 int sessionId;
830 ret = CreateSsAndOpenSession4Data();
831 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
832 sessionId = GetCurrentSessionId4Data();
833
834 ret = GetPeerSessionName(sessionId, NULL, SESSION_NAME_SIZE_MAX);
835 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "GetPeerSessionName invalid sname[null]";
836
837 ret = CloseSessionAndRemoveSs4Data();
838 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
839 }
840
841 /**
842 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3500
843 * @tc.name : GetPeersessionName input PeerSessionName invalid len[max+1]
844 * @tc.desc : Test session management reliability
845 * @tc.type : RELI
846 * @tc.size : MediumTest
847 */
848 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3500, TestSize.Level3)
849 {
850 int ret;
851 int sessionId;
852 ret = CreateSsAndOpenSession4Data();
853 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
854 sessionId = GetCurrentSessionId4Data();
855
856 char peerSname[SESSION_NAME_SIZE_MAX] = { 0 };
857 ret = GetPeerSessionName(sessionId, peerSname, SESSION_NAME_SIZE_MAX + 1);
858 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "GetPeerSessionName invalid len[max+1]";
859
860 ret = CloseSessionAndRemoveSs4Data();
861 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
862 }
863
864 /**
865 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3600
866 * @tc.name : GetPeersessionName input PeerSessionName len short than real
867 * @tc.desc : Test session management reliability
868 * @tc.type : RELI
869 * @tc.size : MediumTest
870 */
871 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3600, TestSize.Level3)
872 {
873 int ret;
874 int sessionId;
875 ret = CreateSsAndOpenSession4Data();
876 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
877 sessionId = GetCurrentSessionId4Data();
878
879 char peerSnameShort[5];
880 ret = GetPeerSessionName(sessionId, peerSnameShort, 5);
881 EXPECT_NE(SOFTBUS_OK, ret) << "GetPeerSessionName len short than real";
882
883 ret = CloseSessionAndRemoveSs4Data();
884 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
885 }
886
887 /**
888 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3700
889 * @tc.name : GetPeerDeviceId input DeviceId invalid sid -1
890 * @tc.desc : 【G-DISTRIBUTED-0205】禁止修改Openharmony分布式软总线设备间传输通道管理协议。
891 * @tc.type : RELI
892 * @tc.size : MediumTest
893 */
894 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3700, TestSize.Level3)
895 {
896 int ret;
897 int sessionId;
898 ret = CreateSsAndOpenSession4Data();
899 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
900 sessionId = GetCurrentSessionId4Data();
901
902 char deviceId[SESSION_NAME_SIZE_MAX] = { 0 };
903 ret = GetPeerDeviceId(-1, deviceId, SESSION_NAME_SIZE_MAX);
904 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "GetPeerDeviceId invalid sid[-1]";
905
906 ret = CloseSessionAndRemoveSs4Data();
907 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
908 }
909
910 /**
911 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3800
912 * @tc.name : GetPeerDeviceId input DeviceId invalid sid[max+1]
913 * @tc.desc : Test session management reliability
914 * @tc.type : RELI
915 * @tc.size : MediumTest
916 */
917 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3800, TestSize.Level3)
918 {
919 int ret;
920 int sessionId;
921 ret = CreateSsAndOpenSession4Data();
922 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
923 sessionId = GetCurrentSessionId4Data();
924
925 char deviceId[SESSION_NAME_SIZE_MAX] = { 0 };
926 ret = GetPeerDeviceId(MAX_SESSION_NUM + 1, deviceId, SESSION_NAME_SIZE_MAX);
927 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret) << "GetPeerDeviceId invalid sid[max+1]";
928
929 ret = CloseSessionAndRemoveSs4Data();
930 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
931 }
932
933 /**
934 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_3900
935 * @tc.name : GetPeerDeviceId input DeviceId invalid sid not open
936 * @tc.desc : 【G-DISTRIBUTED-0205】禁止修改Openharmony分布式软总线设备间传输通道管理协议。
937 * @tc.type : RELI
938 * @tc.size : MediumTest
939 */
940 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_3900, TestSize.Level3)
941 {
942 int ret;
943 int sessionId;
944 ret = CreateSsAndOpenSession4Data();
945 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
946
947 char deviceId[SESSION_NAME_SIZE_MAX] = { 0 };
948 sessionId = GetCurrentSessionId4Data();
949 ret = GetPeerDeviceId(sessionId + 1, deviceId, SESSION_NAME_SIZE_MAX);
950 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret) << "GetPeerDeviceId invalid sid[not open]";
951 ret = CloseSessionAndRemoveSs4Data();
952 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
953 }
954
955 /**
956 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4000
957 * @tc.name : GetPeerDeviceId input DeviceId invalid sname[null]
958 * @tc.desc : 【G-DISTRIBUTED-0205】禁止修改Openharmony分布式软总线设备间传输通道管理协议。
959 * @tc.type : RELI
960 * @tc.size : MediumTest
961 */
962 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4000, TestSize.Level3)
963 {
964 int ret;
965 int sessionId;
966 ret = CreateSsAndOpenSession4Data();
967 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
968 sessionId = GetCurrentSessionId4Data();
969
970 ret = GetPeerDeviceId(sessionId, NULL, SESSION_NAME_SIZE_MAX);
971 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "GetPeerDeviceId invalid sname[null]";
972
973 ret = CloseSessionAndRemoveSs4Data();
974 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
975 }
976 /**
977 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4100
978 * @tc.name : GetPeerDeviceId input DeviceId invalid len[max+1]
979 * @tc.desc : Test session management reliability
980 * @tc.type : RELI
981 * @tc.size : MediumTest
982 */
983 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4100, TestSize.Level3)
984 {
985 int ret;
986 int sessionId;
987 ret = CreateSsAndOpenSession4Data();
988 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
989 sessionId = GetCurrentSessionId4Data();
990
991 char deviceId[SESSION_NAME_SIZE_MAX] = { 0 };
992 ret = GetPeerDeviceId(sessionId, deviceId, SESSION_NAME_SIZE_MAX + 1);
993 EXPECT_EQ(EXPECT_INVALID_PARAM, ret) << "GetPeerDeviceId invalid len[max+1]";
994
995 ret = CloseSessionAndRemoveSs4Data();
996 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
997 }
998 /**
999 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4200
1000 * @tc.name : GetPeerDeviceId input DeviceId len short than real
1001 * @tc.desc : Test session management reliability
1002 * @tc.type : RELI
1003 * @tc.size : MediumTest
1004 */
1005 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4200, TestSize.Level3)
1006 {
1007 int ret;
1008 int sessionId;
1009 ret = CreateSsAndOpenSession4Data();
1010 ASSERT_EQ(SOFTBUS_OK, ret) << "CreateSsAndOpenSession4Data fail";
1011 sessionId = GetCurrentSessionId4Data();
1012
1013 char deviceIdShort[5];
1014 ret = GetPeerDeviceId(sessionId, deviceIdShort, 5);
1015 EXPECT_NE(SOFTBUS_OK, ret) << "GetPeerDeviceId len short than real";
1016
1017 ret = CloseSessionAndRemoveSs4Data();
1018 EXPECT_EQ(SOFTBUS_OK, ret) << "CloseSessionAndRemoveSs4Data fail";
1019 }
1020
1021 /**
1022 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4300
1023 * @tc.name : OpenSession, no Session Server exists on the peer
1024 * @tc.desc : Test session management reliability
1025 * @tc.type : RELI
1026 * @tc.size : MediumTest
1027 */
1028 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4300, TestSize.Level3)
1029 {
1030 int ret;
1031 char* softbusPidStart;
1032 char* softbusPidEnd;
1033 softbusPidStart = GetSoftbusPid();
1034 EXPECT_TRUE(softbusPidStart != NULL);
1035
1036 int sessionId;
1037 string notExistSession = "Not Exist Session Name";
1038 ret = CreateSessionServer(DEF_PKG_NAME, notExistSession.c_str(), GetSessionListenser4Ctl());
1039 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret) << "CreateSS-ctrl fail";
1040 ret = CreateSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA, GetSessionListenser4Data());
1041 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS-data fail";
1042
1043 ResetWaitFlag4Data();
1044 sessionId =
1045 OpenSession(SESSION_NAME_DATA, notExistSession.c_str(), GetNetworkId(), DEF_GROUP_ID, GetSessionAttr4Data());
1046 EXPECT_TRUE(sessionId < SESSION_ID_MIN) << "call open session fail, expect success";
1047 ret = Wait4Session(OPEN_SESSION_TIMEOUT, SESSION_4DATA);
1048 EXPECT_NE(SOFTBUS_OK, ret) << "wait session cb success, expect fail";
1049
1050 int timeout = 5;
1051 ResetWaitFlag4Data();
1052 sessionId = OpenSession(SESSION_NAME_DATA, SESSION_NAME_DATA, GetNetworkId(), DEF_GROUP_ID, GetSessionAttr4Data());
1053 SetCurrentSessionId4Data(sessionId);
1054 EXPECT_TRUE(sessionId >= SESSION_ID_MIN) << "OpenSession normal[data] fail, expect success";
1055 ret = Wait4Session(timeout, SESSION_4DATA);
1056 EXPECT_EQ(SOFTBUS_OK, ret) << "wait session cb fail, expect success";
1057
1058 // clean
1059 CloseSession(sessionId);
1060 ret = RemoveSessionServer(DEF_PKG_NAME, notExistSession.c_str());
1061 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret) << "RemoveSS-notExist fail";
1062 ret = RemoveSessionServer(DEF_PKG_NAME, SESSION_NAME_DATA);
1063 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS-data fail";
1064 sleep(timeout);
1065
1066 softbusPidEnd = GetSoftbusPid();
1067 EXPECT_TRUE(softbusPidEnd != NULL);
1068 EXPECT_STREQ(softbusPidStart, softbusPidEnd);
1069 free(softbusPidStart);
1070 free(softbusPidEnd);
1071 }
1072
1073 /**
1074 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4400
1075 * @tc.name : CreateSessionServer, input sessionName Max success
1076 * @tc.desc : Test session management reliability
1077 * @tc.type : RELI
1078 * @tc.size : MediumTest
1079 */
1080 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4400, TestSize.Level3)
1081 {
1082 int ret = CreateSessionServer(DEF_PKG_NAME, SESSIONNAME_MAX, GetSessionListenser4Ctl());
1083 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS-ctrl fail";
1084 ret = RemoveSessionServer(DEF_PKG_NAME, SESSIONNAME_MAX);
1085 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS-ctrl fail";
1086 }
1087
1088 /**
1089 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4500
1090 * @tc.name : CreateSessionServer, input sessionName contains special char
1091 * @tc.desc : Test session management reliability
1092 * @tc.type : RELI
1093 * @tc.size : MediumTest
1094 */
1095 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4500, TestSize.Level3)
1096 {
1097 string sessionName = "com.communication.demo.max.len.#@$%!";
1098 int ret = CreateSessionServer(DEF_PKG_NAME, sessionName.c_str(), GetSessionListenser4Ctl());
1099 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS-ctrl fail";
1100 ret = RemoveSessionServer(DEF_PKG_NAME, sessionName.c_str());
1101 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS-ctrl fail";
1102 }
1103
1104 /**
1105 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4600
1106 * @tc.name : CreateSessionServer, input pkgName Max success
1107 * @tc.desc : Test session management reliability
1108 * @tc.type : RELI
1109 * @tc.size : MediumTest
1110 */
1111 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4600, TestSize.Level3)
1112 {
1113 int ret = CreateSessionServer(PKGNAME_MAX, SESSION_NAME_CTL, GetSessionListenser4Ctl());
1114 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS-ctrl fail";
1115 ret = RemoveSessionServer(PKGNAME_MAX, SESSION_NAME_CTL);
1116 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS-ctrl fail";
1117 }
1118
1119 /**
1120 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4700
1121 * @tc.name : CreateSessionServer, input pkgNameMax and sessionNameMax
1122 * @tc.desc : 【G-DISTRIBUTED-0205】禁止修改Openharmony分布式软总线设备间传输通道管理协议。
1123 * @tc.type : RELI
1124 * @tc.size : MediumTest
1125 */
1126 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4700, TestSize.Level3)
1127 {
1128 int ret = CreateSessionServer(PKGNAME_MAX, SESSIONNAME_MAX, GetSessionListenser4Ctl());
1129 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS-ctrl fail, pkgnamelen:"
1130 << strlen(PKGNAME_MAX) << ",sessionLen:" << strlen(SESSIONNAME_MAX);
1131 ret = RemoveSessionServer(PKGNAME_MAX, SESSIONNAME_MAX);
1132 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS-ctrl fail";
1133 }
1134
1135 /**
1136 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4800
1137 * @tc.name : CreateSessionServer, input pkgName Max+1 failed
1138 * @tc.desc : 【G-DISTRIBUTED-0205】禁止修改Openharmony分布式软总线设备间传输通道管理协议。
1139 * @tc.type : RELI
1140 * @tc.size : MediumTest
1141 */
1142 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4800, TestSize.Level3)
1143 {
1144 int ret = CreateSessionServer(PKGNAME_MAX_OUT, SESSION_NAME_CTL, GetSessionListenser4Ctl());
1145 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret) << "CreateSS-ctrl success";
1146 ret = RemoveSessionServer(PKGNAME_MAX_OUT, SESSION_NAME_CTL);
1147 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret) << "RemoveSS-ctrl fail";
1148 }
1149
1150 /**
1151 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_4900
1152 * @tc.name : CreateSessionServer, input sessionName Max+1 failed
1153 * @tc.desc : 【G-DISTRIBUTED-0205】禁止修改Openharmony分布式软总线设备间传输通道管理协议。
1154 * @tc.type : RELI
1155 * @tc.size : MediumTest
1156 */
1157 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_4900, TestSize.Level3)
1158 {
1159 int ret = CreateSessionServer(DEF_PKG_NAME, SESSIONNAME_MAX_OUT, GetSessionListenser4Ctl());
1160 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret) << "CreateSS-ctrl success";
1161 ret = RemoveSessionServer(DEF_PKG_NAME, SESSIONNAME_MAX_OUT);
1162 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret) << "RemoveSS-ctrl success";
1163 }
1164
1165 /**
1166 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_5000
1167 * @tc.name : CreateSessionServer, input pkgName contains special char
1168 * @tc.desc : 【G-DISTRIBUTED-0205】禁止修改Openharmony分布式软总线设备间传输通道管理协议。
1169 * @tc.type : RELI
1170 * @tc.size : MediumTest
1171 */
1172 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_5000, TestSize.Level3)
1173 {
1174 int ret = CreateSessionServer(DEF_PKG_NAME, SESSIONNAME_MAX, GetSessionListenser4Ctl());
1175 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS-ctrl fail";
1176 ret = RemoveSessionServer(DEF_PKG_NAME, SESSIONNAME_MAX);
1177 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS-ctrl fail";
1178 ret = CreateSessionServer(PKGNAME_MAX, SESSIONNAME_MAX, GetSessionListenser4Ctl());
1179 EXPECT_EQ(SOFTBUS_OK, ret) << "CreateSS-ctrl fail";
1180 ret = RemoveSessionServer(PKGNAME_MAX, SESSIONNAME_MAX);
1181 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS-ctrl fail";
1182 string pkgName = "com.communication.demo.max.len.#@$%!";
1183 ret = CreateSessionServer(pkgName.c_str(), SESSION_NAME_DATA, GetSessionListenser4Data());
1184 EXPECT_EQ(SOFTBUS_INVALID_PKGNAME, ret) << "CreateSS-ctrl success";
1185 ret = RemoveSessionServer(pkgName.c_str(), SESSION_NAME_DATA);
1186 EXPECT_EQ(SOFTBUS_OK, ret) << "RemoveSS-ctrl success";
1187 }
1188
1189 /**
1190 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_5100
1191 * @tc.name : CreateSessionServer, input invalid sessionName failed
1192 * @tc.desc : 【G-DISTRIBUTED-0211】出于安全和兼容性考虑，不应修改安全相关逻辑，不应变更软总线依赖的安全和协议部件。
1193 * @tc.type : RELI
1194 * @tc.size : MediumTest
1195 */
1196 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_OpenSession_Reli_5100, TestSize.Level3)
1197 {
1198 string sessionName = "com.communication.test.demo";
1199 int ret = CreateSessionServer(DEF_PKG_NAME, sessionName.c_str(), GetSessionListenser4Ctl());
1200 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret) << "CreateSS-ctrl success";
1201 ret = RemoveSessionServer(DEF_PKG_NAME, sessionName.c_str());
1202 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret) << "RemoveSS-ctrl fail";
1203 }
1204
1205 /**
1206 * @tc.number : SUB_Softbus_Trans_Comp_OpenSession_Reli_5200
1207 * @tc.name : GetNodeKeyInfoTestCase
1208 * @tc.desc : GetNodeKeyInfo Performance Testing
1209 * @tc.type : RELI
1210 * @tc.size : MediumTest
1211 */
1212
1213 HWTEST_F(TransReliabilityTest, SUB_Softbus_Trans_Comp_GetNodeKey_Reli_5200, TestSize.Level3)
1214 {
1215 int ret;
1216 NodeBasicInfo info;
1217 char udid[UDID_BUF_LEN] = {0};
1218 (void)memset_s(&info, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
1219 GetLocalNodeDeviceInfo(DEF_PKG_NAME, &info);
1220 ret = GetNodeKeyInfo(DEF_PKG_NAME, info.networkId, NODE_KEY_UDID,
1221 (uint8_t *)udid, UDID_BUF_LEN);
1222 EXPECT_EQ(0, ret) << "GetNodeKeyInfoTestCase failed.";
1223 }