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 <securec.h>
17
18 #include <gtest/gtest.h>
19 #include "softbus_def.h"
20 #include "softbus_errcode.h"
21 #include "softbus_log.h"
22 #include "softbus_app_info.h"
23 #include "softbus_server_frame.h"
24 #include "softbus_adapter_mem.h"
25 #include "trans_session_manager.h"
26 #include "trans_session_service.h"
27
28 using namespace testing::ext;
29
30 #define TRANS_TEST_INVALID_PID (-1)
31 #define TRANS_TEST_INVALID_UID (-1)
32
33 namespace OHOS {
34
35 const char *g_pkgName = "dms";
36 const char *g_sessionName = "ohos.distributedschedule.dms.test";
37 const char *g_networkId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00";
38 const char *g_deviceId = "ABCDEF00ABCDEF00ABCDEF00";
39 const char *g_groupid = "TEST_GROUP_ID";
40 static SessionAttribute g_sessionAttr = {
41 .dataType = TYPE_BYTES,
42 };
43
44 class TransSessionServiceTest : public testing::Test {
45 public:
TransSessionServiceTest()46 TransSessionServiceTest()
47 {}
~TransSessionServiceTest()48 ~TransSessionServiceTest()
49 {}
50 static void SetUpTestCase(void);
51 static void TearDownTestCase(void);
SetUp()52 void SetUp() override
53 {}
TearDown()54 void TearDown() override
55 {}
56 };
57
SetUpTestCase(void)58 void TransSessionServiceTest::SetUpTestCase(void)
59 {
60 InitSoftBusServer();
61 }
62
TearDownTestCase(void)63 void TransSessionServiceTest::TearDownTestCase(void)
64 {
65 }
66
67 /**
68 * @tc.name: TransSessionServiceTest01
69 * @tc.desc: Transmission session service create session with invalid parameters.
70 * @tc.type: FUNC
71 * @tc.require:
72 */
73 HWTEST_F(TransSessionServiceTest, TransSessionServiceTest01, TestSize.Level1)
74 {
75 int32_t ret = TransCreateSessionServer(NULL, g_sessionName, TRANS_TEST_INVALID_UID, TRANS_TEST_INVALID_PID);
76 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
77 ret = TransCreateSessionServer(g_pkgName, NULL, TRANS_TEST_INVALID_UID, TRANS_TEST_INVALID_PID);
78 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
79 }
80
81 /**
82 * @tc.name: TransSessionServiceTest02
83 * @tc.desc: Transmission session service create session with existed session.
84 * @tc.type: FUNC
85 * @tc.require:
86 */
87 HWTEST_F(TransSessionServiceTest, TransSessionServiceTest02, TestSize.Level1)
88 {
89 SessionServer *sessionServer = (SessionServer*)SoftBusMalloc(sizeof(SessionServer));
90 EXPECT_TRUE(sessionServer != NULL);
91 memset_s(sessionServer, sizeof(SessionServer), 0, sizeof(SessionServer));
92 int32_t ret = strcpy_s(sessionServer->sessionName, sizeof(sessionServer->sessionName), g_sessionName);
93 EXPECT_EQ(ret, EOK);
94 ret = strcpy_s(sessionServer->pkgName, sizeof(sessionServer->pkgName), g_pkgName);
95 EXPECT_EQ(ret, EOK);
96 ret = TransSessionServerAddItem(sessionServer);
97 EXPECT_EQ(ret, SOFTBUS_OK);
98 ret = TransCreateSessionServer(g_pkgName, g_sessionName, TRANS_TEST_INVALID_UID, TRANS_TEST_INVALID_PID);
99 EXPECT_EQ(ret, SOFTBUS_SERVER_NAME_REPEATED);
100 ret = TransSessionServerDelItem(g_sessionName);
101 EXPECT_EQ(ret, SOFTBUS_OK);
102 }
103
104 /**
105 * @tc.name: TransSessionServiceTest03
106 * @tc.desc: Transmission session service create session with invalid and wrong parameters.
107 * @tc.type: FUNC
108 * @tc.require:
109 */
110 HWTEST_F(TransSessionServiceTest, TransSessionServiceTest03, TestSize.Level1)
111 {
112 int32_t ret = TransRemoveSessionServer(NULL, g_sessionName);
113 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
114 ret = TransRemoveSessionServer(g_pkgName, NULL);
115 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
116 ret = TransRemoveSessionServer(g_pkgName, g_sessionName);
117 EXPECT_EQ(ret, SOFTBUS_OK);
118 }
119
120 /**
121 * @tc.name: TransSessionServiceTest04
122 * @tc.desc: Transmission session service open session with invalid parameters.
123 * @tc.type: FUNC
124 * @tc.require:
125 */
126 HWTEST_F(TransSessionServiceTest, TransSessionServiceTest04, TestSize.Level1)
127 {
128 SessionParam sessionPara;
129 memset_s(&sessionPara, sizeof(SessionParam), 0, sizeof(SessionParam));
130 TransInfo *transInfo = (TransInfo*)SoftBusCalloc(sizeof(TransInfo));
131 EXPECT_TRUE(transInfo != NULL);
132 memset_s(transInfo, sizeof(TransInfo), 0, sizeof(TransInfo));
133 int32_t ret = TransOpenSession(&sessionPara, transInfo);
134 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
135 sessionPara.sessionName = g_sessionName;
136 ret = TransOpenSession(&sessionPara, transInfo);
137 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
138 sessionPara.peerSessionName = g_sessionName;
139 ret = TransOpenSession(&sessionPara, transInfo);
140 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
141 sessionPara.peerDeviceId = g_deviceId;
142 ret = TransOpenSession(&sessionPara, transInfo);
143 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_GROUP_INVALID);
144 char groupId[] = {"ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00AB"};
145 sessionPara.groupId = groupId;
146 ret = TransOpenSession(&sessionPara, transInfo);
147 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_GROUP_INVALID);
148 sessionPara.groupId = g_groupid;
149 ret = TransOpenSession(&sessionPara, transInfo);
150 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NAME_NO_EXIST);
151 SoftBusFree(transInfo);
152 }
153
154 /**
155 * @tc.name: TransSessionServiceTest05
156 * @tc.desc: Transmission session service open session with not wrong session.
157 * @tc.type: FUNC
158 * @tc.require:
159 */
160 HWTEST_F(TransSessionServiceTest, TransSessionServiceTest05, TestSize.Level1)
161 {
162 SessionServer *sessionServer = (SessionServer*)SoftBusMalloc(sizeof(SessionServer));
163 EXPECT_TRUE(sessionServer != NULL);
164 memset_s(sessionServer, sizeof(SessionServer), 0, sizeof(SessionServer));
165 int32_t ret = strcpy_s(sessionServer->sessionName, sizeof(sessionServer->sessionName), g_sessionName);
166 EXPECT_EQ(ret, EOK);
167 ret = strcpy_s(sessionServer->pkgName, sizeof(sessionServer->pkgName), g_pkgName);
168 EXPECT_EQ(ret, EOK);
169 ret = TransSessionServerAddItem(sessionServer);
170 TransInfo *transInfo = (TransInfo*)SoftBusCalloc(sizeof(TransInfo));
171 EXPECT_TRUE(transInfo != NULL);
172 memset_s(transInfo, sizeof(TransInfo), 0, sizeof(TransInfo));
173 SessionParam sessionPara;
174 memset_s(&sessionPara, sizeof(SessionParam), 0, sizeof(SessionParam));
175 sessionPara.sessionName = g_sessionName;
176 sessionPara.peerSessionName = g_sessionName;
177 sessionPara.peerDeviceId = g_deviceId;
178 sessionPara.groupId = g_groupid;
179 sessionPara.attr = &g_sessionAttr;
180 ret = TransOpenSession(&sessionPara, transInfo);
181 EXPECT_TRUE(ret != SOFTBUS_OK);
182 ret = TransSessionServerDelItem(g_sessionName);
183 EXPECT_EQ(ret, SOFTBUS_OK);
184 SoftBusFree(transInfo);
185 }
186
187 /**
188 * @tc.name: TransSessionServiceTest06
189 * @tc.desc: Transmission session service initialize and deinitialize.
190 * @tc.type: FUNC
191 * @tc.require:
192 */
193 HWTEST_F(TransSessionServiceTest, TransSessionServiceTest06, TestSize.Level1)
194 {
195 TransServerDeathCallback(g_pkgName);
196 int ret = TransServerInit();
197 EXPECT_EQ(ret, SOFTBUS_OK);
198 TransServerDeinit();
199 }
200 }