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
16 #include <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19
20 #include "auth_interface.h"
21 #include "client_trans_message_service.c"
22 #include "softbus_app_info.h"
23 #include "softbus_adapter_mem.h"
24 #include "softbus_common.h"
25 #include "softbus_conn_interface.h"
26 #include "softbus_config_type.h"
27 #include "softbus_def.h"
28 #include "softbus_error_code.h"
29 #include "softbus_json_utils.h"
30 #include "softbus_server_frame.h"
31 #include "softbus_trans_def.h"
32 #include "trans_log.h"
33 #include "trans_common_mock.h"
34 #include "trans_session_mgr_mock.h"
35 #include "trans_session_svc_mock.h"
36
37 #define TRANS_TEST_BEYOND_MAX_BYTES_LEN (6 * 1024 * 1024)
38 #define TRANS_TEST_INVALID_SEND_LEN (1024 * 1024)
39 #define TRANS_TEST_SEND_LEN 123
40 #define OH_OS_INVALID_TYPE 0
41
42 using namespace std;
43 using namespace testing;
44 using namespace testing::ext;
45 using testing::NiceMock;
46
47 namespace OHOS {
48
49 class TransClientMsgServiceExTest : public testing::Test {
50 public:
TransClientMsgServiceExTest()51 TransClientMsgServiceExTest()
52 {}
~TransClientMsgServiceExTest()53 ~TransClientMsgServiceExTest()
54 {}
SetUpTestCase(void)55 static void SetUpTestCase(void)
56 {}
TearDownTestCase(void)57 static void TearDownTestCase(void)
58 {}
SetUp()59 void SetUp() override
60 {}
TearDown()61 void TearDown() override
62 {}
63 };
64
65 typedef enum {
66 EXCUTE_IN_FIRST_TIME = 1,
67 EXCUTE_IN_SECOND_TIME,
68 EXCUTE_IN_THIRD_TIME,
69 EXCUTE_IN_FOURTH_TIME,
70 EXCUTE_IN_FIFTH_TIME,
71 EXCUTE_IN_SIXTH_TIME
72 } ExcuteTimes;
73
74 /**
75 * @tc.name: CheckSendLenForBoosterTest01
76 * @tc.desc: CheckSendLenForBooster with different parameters.
77 * @tc.type: FUNC
78 * @tc.require:
79 */
80 HWTEST_F(TransClientMsgServiceExTest, CheckSendLenForBoosterTest01, TestSize.Level1)
81 {
82 NiceMock<TransCommInterfaceMock> transCommInterfaceMock;
83 EXPECT_CALL(transCommInterfaceMock, SoftbusGetConfig).WillOnce(Return(SOFTBUS_INVALID_PARAM))
84 .WillRepeatedly(TransCommInterfaceMock::ActionOfSoftbusGetConfig);
85
86 int32_t ret = CheckSendLenForBooster(TRANS_TEST_INVALID_SEND_LEN);
87 EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
88
89 ret = CheckSendLenForBooster(TRANS_TEST_BEYOND_MAX_BYTES_LEN);
90 EXPECT_EQ(ret, SOFTBUS_TRANS_SEND_LEN_BEYOND_LIMIT);
91
92 ret = CheckSendLenForBooster(0);
93 EXPECT_EQ(ret, SOFTBUS_OK);
94 }
95
96 /**
97 * @tc.name: TransClientMsgServiceTest01
98 * @tc.desc: Transmission sdk message service check send length with different parameters.
99 * @tc.type: FUNC
100 * @tc.require:
101 */
102 HWTEST_F(TransClientMsgServiceExTest, TransClientMsgServiceTest01, TestSize.Level1)
103 {
104 NiceMock<TransSessionMgrMock> transSessionMgrMock;
105 EXPECT_CALL(transSessionMgrMock, ClientGetDataConfigByChannelId).WillOnce(Return(SOFTBUS_INVALID_PARAM))
106 .WillOnce(TransSessionMgrMock::ActionOfClientGetDataConfigByChannelId).WillRepeatedly(Return(SOFTBUS_OK));
107
108 int32_t ret = CheckSendLen(CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, TRANS_TEST_SEND_LEN, BUSINESS_TYPE_MESSAGE);
109 EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
110
111 ret = CheckSendLen(CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, TRANS_TEST_SEND_LEN, BUSINESS_TYPE_MESSAGE);
112 EXPECT_EQ(ret, SOFTBUS_TRANS_SEND_LEN_BEYOND_LIMIT);
113
114 NiceMock<TransSessionSvcMock> transSessionSvcMock;
115 EXPECT_CALL(transSessionSvcMock, GetDefaultConfigType).WillOnce(Return(SOFTBUS_CONFIG_TYPE_MAX))
116 .WillRepeatedly(Return(SOFTBUS_INT_STATIC_NET_CAPABILITY));
117
118 ret = CheckSendLen(CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, TRANS_TEST_SEND_LEN, BUSINESS_TYPE_MESSAGE);
119 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
120
121 NiceMock<TransCommInterfaceMock> transCommInterfaceMock;
122 EXPECT_CALL(transCommInterfaceMock, SoftbusGetConfig).WillOnce(Return(SOFTBUS_INVALID_PARAM))
123 .WillRepeatedly(TransCommInterfaceMock::ActionOfSoftbusGetConfig);
124
125 ret = CheckSendLen(CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, TRANS_TEST_SEND_LEN, BUSINESS_TYPE_MESSAGE);
126 EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
127
128 ret = CheckSendLen(CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, INVALID_DATA_CONFIG, BUSINESS_TYPE_MESSAGE);
129 EXPECT_EQ(ret, SOFTBUS_OK);
130 }
131
132 /**
133 * @tc.name: CheckBusinessTypeAndOsTypeBySessionIdTest01
134 * @tc.desc: CheckBusinessTypeAndOsTypeBySessionId with different parameters.
135 * @tc.type: FUNC
136 * @tc.require:
137 */
138 HWTEST_F(TransClientMsgServiceExTest, CheckBusinessTypeAndOsTypeBySessionIdTest01, TestSize.Level1)
139 {
140 NiceMock<TransSessionMgrMock> transSessionMgrMock;
141 EXPECT_CALL(transSessionMgrMock, ClientGetDataConfigByChannelId).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
142 EXPECT_CALL(transSessionMgrMock, ClientGetChannelOsTypeBySessionId).WillRepeatedly(
__anonf93b97b40202(int32_t sessionId, int32_t *osType) 143 [](int32_t sessionId, int32_t *osType) -> int32_t {
144 (void)sessionId;
145 static int32_t times = 0;
146 times++;
147 *osType = OH_OS_TYPE;
148 if (times == EXCUTE_IN_FIRST_TIME) {
149 *osType = OH_OS_INVALID_TYPE;
150 return SOFTBUS_OK;
151 }
152 return SOFTBUS_OK;
153 });
154 EXPECT_CALL(transSessionMgrMock, ClientGetChannelBusinessTypeBySessionId).WillRepeatedly(
__anonf93b97b40302(int32_t sessionId, int32_t *businessType) 155 [](int32_t sessionId, int32_t *businessType) -> int32_t {
156 (void)sessionId;
157 static int32_t times = 0;
158 times++;
159 *businessType = BUSINESS_TYPE_BUTT;
160 if (times == EXCUTE_IN_FIRST_TIME) {
161 *businessType = BUSINESS_TYPE_MESSAGE;
162 return SOFTBUS_OK;
163 }
164 if (times == EXCUTE_IN_SECOND_TIME) {
165 *businessType = BUSINESS_TYPE_BYTE;
166 return SOFTBUS_OK;
167 }
168 if (times == EXCUTE_IN_THIRD_TIME) {
169 *businessType = BUSINESS_TYPE_NOT_CARE;
170 return SOFTBUS_OK;
171 }
172 return SOFTBUS_OK;
173 });
174 NiceMock<TransCommInterfaceMock> transCommInterfaceMock;
175 EXPECT_CALL(transCommInterfaceMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
176
177 int32_t ret = CheckBusinessTypeAndOsTypeBySessionId(0, 0, CHANNEL_TYPE_UDP, 0);
178 EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
179
180 ret = CheckBusinessTypeAndOsTypeBySessionId(0, 0, CHANNEL_TYPE_UDP, 0);
181 EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
182
183 ret = CheckBusinessTypeAndOsTypeBySessionId(0, 0, CHANNEL_TYPE_UDP, 0);
184 EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
185
186 ret = CheckBusinessTypeAndOsTypeBySessionId(0, 0, CHANNEL_TYPE_AUTH, 0);
187 EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
188
189 ret = CheckBusinessTypeAndOsTypeBySessionId(0, 0, CHANNEL_TYPE_UDP, 0);
190 EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
191 }
192
ActionOfGetSupportTlvAndNeedAckById(int32_t channelId,int32_t channelType,bool * supportTlv,bool * needAck)193 int32_t ActionOfGetSupportTlvAndNeedAckById(int32_t channelId, int32_t channelType, bool *supportTlv, bool *needAck)
194 {
195 (void)channelId;
196 (void)channelType;
197 static int32_t times = 0;
198 times++;
199 if (times == EXCUTE_IN_FIRST_TIME) {
200 return SOFTBUS_INVALID_PARAM;
201 }
202 if (times == EXCUTE_IN_SECOND_TIME) {
203 *supportTlv = false;
204 *needAck = true;
205 return SOFTBUS_OK;
206 }
207 if (times == EXCUTE_IN_THIRD_TIME) {
208 *supportTlv = true;
209 *needAck = false;
210 return SOFTBUS_OK;
211 }
212 if (times == EXCUTE_IN_FOURTH_TIME) {
213 *supportTlv = false;
214 *needAck = false;
215 return SOFTBUS_OK;
216 }
217 *supportTlv = true;
218 *needAck = true;
219 return SOFTBUS_OK;
220 }
221
222 /**
223 * @tc.name: CheckAsyncSendBytesFuncTest01
224 * @tc.desc: CheckAsyncSendBytesFunc with different parameters.
225 * @tc.type: FUNC
226 * @tc.require:
227 */
228 HWTEST_F(TransClientMsgServiceExTest, CheckAsyncSendBytesFuncTest01, TestSize.Level1)
229 {
230 NiceMock<TransSessionMgrMock> transSessionMgrMock;
231 EXPECT_CALL(transSessionMgrMock, GetSupportTlvAndNeedAckById)
232 .WillRepeatedly(ActionOfGetSupportTlvAndNeedAckById);
233
234 int32_t ret = CheckAsyncSendBytesFunc(0, CHANNEL_TYPE_UDP);
235 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
236
237 ret = CheckAsyncSendBytesFunc(0, CHANNEL_TYPE_UDP);
238 EXPECT_EQ(ret, SOFTBUS_TRANS_NOT_SUPPORT_ASYNC_SEND_BYTES);
239
240 ret = CheckAsyncSendBytesFunc(0, CHANNEL_TYPE_UDP);
241 EXPECT_EQ(ret, SOFTBUS_TRANS_NOT_SUPPORT_ASYNC_SEND_BYTES);
242
243 ret = CheckAsyncSendBytesFunc(0, CHANNEL_TYPE_UDP);
244 EXPECT_EQ(ret, SOFTBUS_TRANS_NOT_SUPPORT_ASYNC_SEND_BYTES);
245
246 ret = CheckAsyncSendBytesFunc(0, CHANNEL_TYPE_UDP);
247 EXPECT_EQ(ret, SOFTBUS_OK);
248 }
249 }
250