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