1 /*
2 * Copyright (c) 2025 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 #include <gtest/gtest.h>
16
17 #include "client_trans_socket_service.c"
18 #include "softbus_error_code.h"
19 #include "trans_type.h"
20 #include "trans_common_mock.h"
21 #include "trans_session_mgr_mock.h"
22 #include "trans_session_svc_mock.h"
23 #include "trans_socket_mgr_mock.h"
24
25 using namespace std;
26 using namespace testing;
27 using namespace testing::ext;
28 using testing::NiceMock;
29
30 #define STRING_INFO_SIZE 20
31 #define DEFAULT_MAX_WAIT_TIMEOUT 30000
32
33 namespace OHOS {
34
35 class ClientTransSocketExTest : public testing::Test { };
36
37 static ClientEnhanceFuncList g_pfnClientEnhanceFuncList;
38
39 typedef enum {
40 EXCUTE_IN_FIRST_TIME = 1,
41 EXCUTE_IN_SECOND_TIME,
42 EXCUTE_IN_THIRD_TIME,
43 EXCUTE_IN_FOURTH_TIME,
44 EXCUTE_IN_FIFTH_TIME,
45 EXCUTE_IN_SIXTH_TIME
46 } ExcuteTimes;
47
MySetExtSocketOptFunc(int32_t socket,OptLevel level,OptType optType,void * optValue,uint32_t optValueSize)48 int32_t MySetExtSocketOptFunc(int32_t socket, OptLevel level, OptType optType, void *optValue, uint32_t optValueSize)
49 {
50 (void)socket;
51 (void)level;
52 (void)optType;
53 (void)optValue;
54 (void)optValueSize;
55 return SOFTBUS_OK;
56 }
57
58 /*
59 * @tc.name: ClientCheckFuncPointerTest001
60 * @tc.desc: ClientCheckFuncPointer with different parameters.
61 * @tc.type: FUNC
62 * @tc.require:
63 */
64 HWTEST_F(ClientTransSocketExTest, ClientCheckFuncPointerTest001, TestSize.Level1)
65 {
66 int32_t ret = ClientCheckFuncPointer(nullptr);
67 EXPECT_EQ(ret, SOFTBUS_FUNC_NOT_REGISTER);
68
69 ret = ClientCheckFuncPointer(reinterpret_cast<void *>(MySetExtSocketOptFunc));
70 EXPECT_EQ(ret, SOFTBUS_OK);
71 }
72
73 /*
74 * @tc.name: SetExtSocketOptPackedTest001
75 * @tc.desc: SetExtSocketOptPacked with different parameters.
76 * @tc.type: FUNC
77 * @tc.require:
78 */
79 HWTEST_F(ClientTransSocketExTest, SetExtSocketOptPackedTest001, TestSize.Level1)
80 {
81 NiceMock<TransCommInterfaceMock> transCommInterfaceMock;
82 g_pfnClientEnhanceFuncList.setExtSocketOpt = nullptr;
83 EXPECT_CALL(transCommInterfaceMock, ClientEnhanceFuncListGet).WillOnce(Return(&g_pfnClientEnhanceFuncList))
__anonec7874380202() 84 .WillRepeatedly([]() -> ClientEnhanceFuncList* {
85 g_pfnClientEnhanceFuncList.setExtSocketOpt = MySetExtSocketOptFunc;
86 return &g_pfnClientEnhanceFuncList;
87 });
88 int32_t ret = SetExtSocketOptPacked(0, OPT_LEVEL_SOFTBUS, OPT_TYPE_BEGIN, nullptr, 0);
89 EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
90
91 ret = SetExtSocketOptPacked(0, OPT_LEVEL_SOFTBUS, OPT_TYPE_BEGIN, nullptr, 0);
92 EXPECT_EQ(ret, SOFTBUS_OK);
93 }
94
MyGetExtSocketOptFunc(int32_t socket,OptLevel level,OptType optType,void * optValue,int32_t * optValueSize)95 int32_t MyGetExtSocketOptFunc(int32_t socket, OptLevel level, OptType optType, void *optValue, int32_t *optValueSize)
96 {
97 (void)socket;
98 (void)level;
99 (void)optType;
100 (void)optValue;
101 (void)optValueSize;
102 return SOFTBUS_OK;
103 }
104
105 /*
106 * @tc.name: GetExtSocketOptPackedTest001
107 * @tc.desc: GetExtSocketOptPacked with different parameters.
108 * @tc.type: FUNC
109 * @tc.require:
110 */
111 HWTEST_F(ClientTransSocketExTest, GetExtSocketOptPackedTest001, TestSize.Level1)
112 {
113 NiceMock<TransCommInterfaceMock> transCommInterfaceMock;
114 g_pfnClientEnhanceFuncList.getExtSocketOpt = nullptr;
115 EXPECT_CALL(transCommInterfaceMock, ClientEnhanceFuncListGet).WillOnce(Return(&g_pfnClientEnhanceFuncList))
__anonec7874380302() 116 .WillRepeatedly([]() -> ClientEnhanceFuncList* {
117 g_pfnClientEnhanceFuncList.getExtSocketOpt = MyGetExtSocketOptFunc;
118 return &g_pfnClientEnhanceFuncList;
119 });
120 int32_t ret = GetExtSocketOptPacked(0, OPT_LEVEL_SOFTBUS, OPT_TYPE_BEGIN, nullptr, nullptr);
121 EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
122
123 ret = GetExtSocketOptPacked(0, OPT_LEVEL_SOFTBUS, OPT_TYPE_BEGIN, nullptr, nullptr);
124 EXPECT_EQ(ret, SOFTBUS_OK);
125 }
126
127 /*
128 * @tc.name: WriteAcessInfoToBufTest001
129 * @tc.desc: WriteAcessInfoToBuf with different parameters.
130 * @tc.type: FUNC
131 * @tc.require:
132 */
133 HWTEST_F(ClientTransSocketExTest, WriteAcessInfoToBufTest001, TestSize.Level1)
134 {
135 NiceMock<TransCommInterfaceMock> transCommInterfaceMock;
136 EXPECT_CALL(transCommInterfaceMock, WriteInt32ToBuf).WillOnce(Return(SOFTBUS_INVALID_PARAM))
137 .WillRepeatedly(Return(SOFTBUS_OK));
138 EXPECT_CALL(transCommInterfaceMock, WriteUint64ToBuf).WillOnce(Return(SOFTBUS_INVALID_PARAM))
139 .WillRepeatedly(Return(SOFTBUS_OK));
140 EXPECT_CALL(transCommInterfaceMock, WriteStringToBuf).WillRepeatedly(
__anonec7874380402(uint8_t *buf, uint32_t bufLen, int32_t *offSet, char *data, uint32_t dataLen) 141 [](uint8_t *buf, uint32_t bufLen, int32_t *offSet, char *data, uint32_t dataLen) -> int32_t {
142 (void)buf;
143 (void)bufLen;
144 (void)offSet;
145 (void)data;
146 (void)dataLen;
147 static int32_t times = 0;
148 times++;
149 if (times == EXCUTE_IN_FIRST_TIME) {
150 return SOFTBUS_INVALID_PARAM;
151 }
152 if (times == EXCUTE_IN_SECOND_TIME) {
153 return SOFTBUS_OK;
154 }
155 if (times == EXCUTE_IN_THIRD_TIME) {
156 return SOFTBUS_INVALID_PARAM;
157 }
158 return SOFTBUS_OK;
159 });
160
161 SocketAccessInfo accessInfo = {
162 .localTokenId = 0,
163 .extraAccessInfo = reinterpret_cast<char *>(SoftBusCalloc(STRING_INFO_SIZE)),
164 };
165 char *sessionName = reinterpret_cast<char *>(SoftBusCalloc(STRING_INFO_SIZE));
166 strcpy_s(sessionName, STRING_INFO_SIZE, "sessionName");
167 strcpy_s(accessInfo.extraAccessInfo, STRING_INFO_SIZE, "extraAccessInfo");
168
169 int32_t ret = WriteAcessInfoToBuf(nullptr, 0, sessionName, &accessInfo);
170 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
171
172 ret = WriteAcessInfoToBuf(nullptr, 0, sessionName, &accessInfo);
173 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
174
175 ret = WriteAcessInfoToBuf(nullptr, 0, sessionName, &accessInfo);
176 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
177
178 ret = WriteAcessInfoToBuf(nullptr, 0, sessionName, &accessInfo);
179 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
180
181 ret = WriteAcessInfoToBuf(nullptr, 0, sessionName, &accessInfo);
182 EXPECT_EQ(ret, SOFTBUS_OK);
183
184 SoftBusFree(sessionName);
185 SoftBusFree(accessInfo.extraAccessInfo);
186 }
187
188 /*
189 * @tc.name: SetAccessInfoTest001
190 * @tc.desc: SetAccessInfo with different parameters.
191 * @tc.type: FUNC
192 * @tc.require:
193 */
194 HWTEST_F(ClientTransSocketExTest, SetAccessInfoTest001, TestSize.Level1)
195 {
196 NiceMock<TransSessionMgrMock> transSessionMgrMock;
197 EXPECT_CALL(transSessionMgrMock, ClientGetSessionNameBySessionId).WillRepeatedly(Return(SOFTBUS_OK));
198
199 SocketAccessInfo accessInfo = {
200 .extraAccessInfo = nullptr,
201 .userId = -1,
202 };
203 int32_t ret = SetAccessInfo(0, accessInfo);
204 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
205
206 accessInfo.userId = 0;
207 ret = SetAccessInfo(0, accessInfo);
208 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
209 accessInfo.userId = -1;
210
211 accessInfo.extraAccessInfo = reinterpret_cast<char *>(SoftBusCalloc(STRING_INFO_SIZE));
212 strcpy_s(accessInfo.extraAccessInfo, STRING_INFO_SIZE, "extraAccessInfo");
213 ret = SetAccessInfo(0, accessInfo);
214 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
215 accessInfo.userId = 0;
216
217 NiceMock<TransCommInterfaceMock> transCommInterfaceMock;
218 EXPECT_CALL(transCommInterfaceMock, WriteInt32ToBuf).WillOnce(Return(SOFTBUS_INVALID_PARAM))
219 .WillRepeatedly(Return(SOFTBUS_OK));
220 EXPECT_CALL(transCommInterfaceMock, WriteUint64ToBuf).WillRepeatedly(Return(SOFTBUS_OK));
221 EXPECT_CALL(transCommInterfaceMock, WriteStringToBuf).WillRepeatedly(Return(SOFTBUS_OK));
222 ret = SetAccessInfo(0, accessInfo);
223 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
224
225 EXPECT_CALL(transCommInterfaceMock, ServerIpcProcessInnerEvent).WillOnce(Return(SOFTBUS_INVALID_PARAM))
226 .WillRepeatedly(Return(SOFTBUS_OK));
227 ret = SetAccessInfo(0, accessInfo);
228 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
229
230 ret = SetAccessInfo(0, accessInfo);
231 EXPECT_EQ(ret, SOFTBUS_OK);
232
233 SoftBusFree(accessInfo.extraAccessInfo);
234 }
235
236 /*
237 * @tc.name: BindAsyncTest001
238 * @tc.desc: BindAsync with different parameters.
239 * @tc.type: FUNC
240 * @tc.require:
241 */
242 HWTEST_F(ClientTransSocketExTest, BindAsyncTest001, TestSize.Level1)
243 {
244 NiceMock<TransSessionMgrMock> transSessionMgrMock;
245 EXPECT_CALL(transSessionMgrMock, IsSessionExceedLimit).WillOnce(Return(true))
246 .WillRepeatedly(Return(false));
247
248 QosTV qos[1];
249 ISocketListener listener;
250 int32_t ret = BindAsync(0, qos, 0, &listener);
251 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_CNT_EXCEEDS_LIMIT);
252
253 NiceMock<TransSocketMgrMock> transSocketMgrMock;
254 EXPECT_CALL(transSocketMgrMock, GetQosValue).WillRepeatedly(
__anonec7874380502(const QosTV *qos, uint32_t qosCount, QosType type, int32_t *value, int32_t defVal) 255 [](const QosTV *qos, uint32_t qosCount, QosType type, int32_t *value, int32_t defVal) -> int32_t {
256 (void)qos;
257 (void)qosCount;
258 (void)type;
259 (void)defVal;
260 *value = DEFAULT_MAX_WAIT_TIMEOUT;
261 return SOFTBUS_OK;
262 });
263 EXPECT_CALL(transSessionMgrMock, ClientHandleBindWaitTimer).WillOnce(Return(SOFTBUS_ALREADY_TRIGGERED))
264 .WillOnce(Return(SOFTBUS_INVALID_PARAM)).WillRepeatedly(Return(SOFTBUS_OK));
265 ret = BindAsync(0, qos, 0, &listener);
266 EXPECT_EQ(ret, SOFTBUS_OK);
267
268 ret = BindAsync(0, qos, 0, &listener);
269 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
270
271 EXPECT_CALL(transSessionMgrMock, SetSessionStateBySessionId).WillRepeatedly(Return(SOFTBUS_OK));
272 NiceMock<TransSessionSvcMock> transSessionSvcMock;
273 EXPECT_CALL(transSessionSvcMock, ClientBind).WillOnce(Return(SOFTBUS_INVALID_PARAM))
274 .WillRepeatedly(Return(SOFTBUS_OK));
275 ret = BindAsync(0, qos, 0, &listener);
276 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
277
278 ret = BindAsync(0, qos, 0, &listener);
279 EXPECT_EQ(ret, SOFTBUS_OK);
280 }
281 } // namespace OHOS
282