1 /*
2 * Copyright (c) 2022-2024 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 "if_system_ability_manager.h"
19 #include "iservice_registry.h"
20 #include "softbus_adapter_mem.h"
21 #include "softbus_client_info_manager.h"
22 #include "softbus_server_death_recipient.h"
23 #include "trans_client_proxy.h"
24
25 using namespace std;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 #define TEST_ERR_PID (-1)
30 #define TEST_LEN 10
31 #define TEST_DATA_TYPE 0
32 #define TEST_PID 2
33 #define TEST_STATE 1
34 #define TEST_ERR_CODE 1
35 #define TEST_CHANNELID 5
36 #define TEST_CHANNELTYPE 2
37 #define TEST_REMOTE_TYPE 0
38 #define TEST_EVENT_ID 2
39 #define TEST_COUNT 2
40
41 const char *g_pkgName = "dms";
42 const char *g_sessionName = "ohos.distributedschedule.dms.test";
43 const char *g_errPkgName = "abc";
44
45 class TransClientProxyTest : public testing::Test {
46 public:
TransClientProxyTest()47 TransClientProxyTest() {}
~TransClientProxyTest()48 ~TransClientProxyTest() {}
49 static void SetUpTestCase(void);
50 static void TearDownTestCase(void);
SetUp()51 void SetUp() override {}
TearDown()52 void TearDown() override {}
53 };
54
SetUpTestCase(void)55 void TransClientProxyTest::SetUpTestCase(void) {}
TearDownTestCase(void)56 void TransClientProxyTest::TearDownTestCase(void) {}
57
BuildChannelMsg(ChannelMsg * data)58 static void BuildChannelMsg(ChannelMsg *data)
59 {
60 data->msgChannelId = TEST_CHANNELID;
61 data->msgChannelType = TEST_CHANNELTYPE;
62 data->msgPid = TEST_PID;
63 data->msgPkgName = g_pkgName;
64 data->msgUuid = nullptr;
65 data->msgUdid = nullptr;
66 }
67
68 /**
69 * @tc.name: InformPermissionChangeTest001
70 * @tc.desc: information permission change test, use the wrong or normal parameter.
71 * @tc.type: FUNC
72 * @tc.require:
73 */
74 HWTEST_F(TransClientProxyTest, InformPermissionChangeTest001, TestSize.Level1)
75 {
76 int32_t ret;
77
78 ret = InformPermissionChange(TEST_STATE, nullptr, TEST_PID);
79 EXPECT_EQ(SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL, ret);
80
81 ret = InformPermissionChange(TEST_STATE, g_pkgName, TEST_PID);
82 EXPECT_EQ(SOFTBUS_TRANS_PROXY_REMOTE_NULL, ret);
83
84 static const uint32_t SOFTBUS_SA_ID = 4700;
85 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
86 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
87 ASSERT_TRUE(remoteObject != nullptr);
88 sptr<IRemoteObject::DeathRecipient> abilityDeath = new (std::nothrow) SoftBusDeathRecipient();
89 ASSERT_TRUE(abilityDeath != nullptr);
90 ret = SoftbusClientInfoManager::GetInstance().SoftbusAddService(g_pkgName, remoteObject, abilityDeath, TEST_PID);
91 EXPECT_EQ(SOFTBUS_OK, ret);
92 ret = InformPermissionChange(TEST_STATE, g_pkgName, TEST_PID);
93 EXPECT_EQ(SOFTBUS_OK, ret);
94 }
95
96 /**
97 * @tc.name: ClientIpcOnChannelOpenedTest001
98 * @tc.desc: client ipc on channel opened test, use the wrong or normal parameter.
99 * @tc.type: FUNC
100 * @tc.require:
101 */
102 HWTEST_F(TransClientProxyTest, ClientIpcOnChannelOpenedTest001, TestSize.Level1)
103 {
104 int32_t ret;
105 ChannelInfo channel;
106 char strTmp[] = "ABCDEFG";
107 channel.channelId = TEST_CHANNELID;
108 channel.channelType = CHANNEL_TYPE_TCP_DIRECT;
109 channel.fd = TEST_DATA_TYPE;
110 channel.isServer = false;
111 channel.isEnabled = true;
112 channel.peerUid = TEST_CHANNELID;
113 channel.peerPid = TEST_CHANNELID;
114 channel.groupId = strTmp;
115 channel.sessionKey = strTmp;
116 channel.keyLen = sizeof(channel.sessionKey);
117 channel.peerSessionName = strTmp;
118 channel.peerDeviceId = strTmp;
119 channel.businessType = TEST_COUNT;
120 channel.myIp = strTmp;
121 channel.streamType = TEST_COUNT;
122 channel.isUdpFile = true;
123 channel.peerPort = TEST_COUNT;
124 channel.peerIp = strTmp;
125 channel.routeType = TEST_DATA_TYPE;
126 channel.encrypt = TEST_COUNT;
127 channel.algorithm = TEST_COUNT;
128 channel.crc = TEST_COUNT;
129
130 ret = ClientIpcOnChannelOpened(g_pkgName, g_sessionName, &channel, TEST_PID);
131 EXPECT_NE(SOFTBUS_INVALID_PARAM, ret);
132
133 static const uint32_t SOFTBUS_SA_ID = 4700;
134 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
135 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
136 ASSERT_TRUE(remoteObject != nullptr);
137 sptr<IRemoteObject::DeathRecipient> abilityDeath = new (std::nothrow) SoftBusDeathRecipient();
138 ASSERT_TRUE(abilityDeath != nullptr);
139 ret = SoftbusClientInfoManager::GetInstance().SoftbusAddService(g_pkgName, remoteObject, abilityDeath, TEST_PID);
140 EXPECT_EQ(SOFTBUS_OK, ret);
141 ret = ClientIpcOnChannelOpened(g_pkgName, g_sessionName, &channel, TEST_PID);
142 EXPECT_NE(SOFTBUS_INVALID_PARAM, ret);
143
144 channel.isServer = false;
145 ret = ClientIpcOnChannelOpened(g_pkgName, g_sessionName, &channel, TEST_PID);
146 EXPECT_NE(SOFTBUS_INVALID_PARAM, ret);
147 }
148
149 /**
150 * @tc.name: ClientIpcOnChannelOpenFailedTest001
151 * @tc.desc: client ipc on channel open failed test, use the wrong or normal parameter.
152 * @tc.type: FUNC
153 * @tc.require:
154 */
155 HWTEST_F(TransClientProxyTest, ClientIpcOnChannelOpenFailedTest001, TestSize.Level1)
156 {
157 int32_t ret;
158 ChannelMsg data;
159 BuildChannelMsg(&data);
160 ret = ClientIpcOnChannelOpenFailed(&data, TEST_ERR_CODE);
161 EXPECT_EQ(SOFTBUS_OK, ret);
162
163 static const uint32_t SOFTBUS_SA_ID = 4700;
164 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
165 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
166 ASSERT_TRUE(remoteObject != nullptr);
167 sptr<IRemoteObject::DeathRecipient> abilityDeath = new (std::nothrow) SoftBusDeathRecipient();
168 ASSERT_TRUE(abilityDeath != nullptr);
169 ret = SoftbusClientInfoManager::GetInstance().SoftbusAddService(g_pkgName, remoteObject, abilityDeath, TEST_PID);
170 EXPECT_EQ(SOFTBUS_OK, ret);
171 ChannelMsg msg;
172 BuildChannelMsg(&msg);
173 ret = ClientIpcOnChannelOpenFailed(&msg, TEST_ERR_CODE);
174 EXPECT_EQ(SOFTBUS_OK, ret);
175 }
176
177 /**
178 * @tc.name: ClientIpcOnChannelLinkDownTest001
179 * @tc.desc: client ipc on channel link down test, use the wrong or normal parameter.
180 * @tc.type: FUNC
181 * @tc.require:
182 */
183 HWTEST_F(TransClientProxyTest, ClientIpcOnChannelLinkDownTest001, TestSize.Level1)
184 {
185 int32_t ret;
186 char networkId[] = "ABCDEFG";
187
188 ChannelMsg data = {
189 .msgPid = TEST_PID,
190 .msgPkgName = g_pkgName,
191 .msgUuid = nullptr,
192 .msgUdid = nullptr
193 };
194 ret = ClientIpcOnChannelLinkDown(&data, networkId, nullptr, TEST_REMOTE_TYPE);
195 EXPECT_EQ(SOFTBUS_OK, ret);
196
197 static const uint32_t SOFTBUS_SA_ID = 4700;
198 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
199 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
200 ASSERT_TRUE(remoteObject != nullptr);
201 sptr<IRemoteObject::DeathRecipient> abilityDeath = new (std::nothrow) SoftBusDeathRecipient();
202 ASSERT_TRUE(abilityDeath != nullptr);
203 ret = SoftbusClientInfoManager::GetInstance().SoftbusAddService(g_pkgName, remoteObject, abilityDeath, TEST_PID);
204 EXPECT_EQ(SOFTBUS_OK, ret);
205 ChannelMsg msg = {
206 .msgPid = TEST_PID,
207 .msgPkgName = g_pkgName,
208 .msgUuid = nullptr,
209 .msgUdid = nullptr
210 };
211 ret = ClientIpcOnChannelLinkDown(&msg, networkId, nullptr, TEST_REMOTE_TYPE);
212 EXPECT_EQ(SOFTBUS_OK, ret);
213 }
214
215 /**
216 * @tc.name: ClientIpcOnChannelClosedTest001
217 * @tc.desc: client ipc on channel closed test, use the wrong or normal parameter.
218 * @tc.type: FUNC
219 * @tc.require:
220 */
221 HWTEST_F(TransClientProxyTest, ClientIpcOnChannelClosedTest001, TestSize.Level1)
222 {
223 int32_t ret;
224 ChannelMsg data;
225 BuildChannelMsg(&data);
226 ret = ClientIpcOnChannelClosed(&data);
227 EXPECT_EQ(SOFTBUS_OK, ret);
228
229 static const uint32_t SOFTBUS_SA_ID = 4700;
230 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
231 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
232 ASSERT_TRUE(remoteObject != nullptr);
233 sptr<IRemoteObject::DeathRecipient> abilityDeath = new (std::nothrow) SoftBusDeathRecipient();
234 ASSERT_TRUE(abilityDeath != nullptr);
235 ret = SoftbusClientInfoManager::GetInstance().SoftbusAddService(g_pkgName, remoteObject, abilityDeath, TEST_PID);
236 EXPECT_EQ(SOFTBUS_OK, ret);
237 ChannelMsg msg;
238 BuildChannelMsg(&msg);
239 ret = ClientIpcOnChannelClosed(&msg);
240 EXPECT_EQ(SOFTBUS_OK, ret);
241 }
242
243 /**
244 * @tc.name: ClientIpcOnChannelMsgReceivedTest001
245 * @tc.desc: client ipc on channel msg received test, use the wrong or normal parameter.
246 * @tc.type: FUNC
247 * @tc.require:
248 */
249 HWTEST_F(TransClientProxyTest, ClientIpcOnChannelMsgReceivedTest001, TestSize.Level1)
250 {
251 int32_t ret;
252
253 TransReceiveData receiveData;
254 receiveData.data = (unsigned char *)SoftBusCalloc(TEST_LEN);
255 ASSERT_TRUE(receiveData.data != nullptr);
256 receiveData.dataLen = TEST_LEN;
257 receiveData.dataType = TEST_DATA_TYPE;
258
259 ChannelMsg data;
260 BuildChannelMsg(&data);
261 ret = ClientIpcOnChannelMsgReceived(&data, &receiveData);
262 EXPECT_EQ(SOFTBUS_OK, ret);
263
264 static const uint32_t SOFTBUS_SA_ID = 4700;
265 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
266 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
267 ASSERT_TRUE(remoteObject != nullptr);
268 sptr<IRemoteObject::DeathRecipient> abilityDeath = new (std::nothrow) SoftBusDeathRecipient();
269 ASSERT_TRUE(abilityDeath != nullptr);
270 ret = SoftbusClientInfoManager::GetInstance().SoftbusAddService(g_pkgName, remoteObject, abilityDeath, TEST_PID);
271 EXPECT_EQ(SOFTBUS_OK, ret);
272 ChannelMsg msg;
273 BuildChannelMsg(&msg);
274 ret = ClientIpcOnChannelMsgReceived(&msg, &receiveData);
275 EXPECT_EQ(SOFTBUS_OK, ret);
276 }
277
278 /**
279 * @tc.name: ClientIpcOnChannelQosEventTest001
280 * @tc.desc: client ipc on channel qos event test, use the wrong or normal parameter.
281 * @tc.type: FUNC
282 * @tc.require:
283 */
284 HWTEST_F(TransClientProxyTest, ClientIpcOnChannelQosEventTest001, TestSize.Level1)
285 {
286 int32_t ret;
287
288 QosParam param;
289 QosTv tvList;
290 param.channelId = TEST_CHANNELID;
291 param.channelType = CHANNEL_TYPE_UDP;
292 param.eventId = TEST_EVENT_ID;
293 param.tvCount = TEST_COUNT;
294 param.tvList = &tvList;
295 param.pid = TEST_PID;
296
297 ret = ClientIpcOnChannelQosEvent(g_pkgName, ¶m);
298 EXPECT_EQ(SOFTBUS_OK, ret);
299
300 static const uint32_t SOFTBUS_SA_ID = 4700;
301 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
302 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
303 ASSERT_TRUE(remoteObject != nullptr);
304 sptr<IRemoteObject::DeathRecipient> abilityDeath = new (std::nothrow) SoftBusDeathRecipient();
305 ASSERT_TRUE(abilityDeath != nullptr);
306 ret = SoftbusClientInfoManager::GetInstance().SoftbusAddService(g_pkgName, remoteObject, abilityDeath, TEST_PID);
307 EXPECT_EQ(SOFTBUS_OK, ret);
308 ret = ClientIpcOnChannelQosEvent(g_pkgName, ¶m);
309 EXPECT_EQ(SOFTBUS_OK, ret);
310 }
311
312 /**
313 * @tc.name: ClientIpcOnChannelBindTest001
314 * @tc.desc: ClientIpcOnChannelBind test.
315 * @tc.type: FUNC
316 * @tc.require:
317 */
318 HWTEST_F(TransClientProxyTest, ClientIpcOnChannelBindTest001, TestSize.Level1)
319 {
320 ChannelMsg *data = nullptr;
321 int32_t ret = ClientIpcOnChannelBind(data);
322 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
323
324 data = (ChannelMsg *)SoftBusCalloc(sizeof(ChannelMsg));
325 ASSERT_NE(nullptr, data);
326 data->msgPid = TEST_PID;
327 ret = ClientIpcOnChannelBind(data);
328 EXPECT_EQ(SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL, ret);
329
330 static const uint32_t SOFTBUS_SA_ID = 4700;
331 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
332 ASSERT_TRUE(saManager != nullptr);
333 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
334 ASSERT_TRUE(remoteObject != nullptr);
335 sptr<IRemoteObject::DeathRecipient> abilityDeath = new (std::nothrow) SoftBusDeathRecipient();
336 ASSERT_TRUE(abilityDeath != nullptr);
337 ret = SoftbusClientInfoManager::GetInstance().SoftbusAddService(g_pkgName, remoteObject, abilityDeath, TEST_PID);
338 EXPECT_EQ(SOFTBUS_OK, ret);
339
340 data->msgPkgName = g_pkgName;
341 ret = ClientIpcOnChannelBind(data);
342 EXPECT_EQ(SOFTBUS_OK, ret);
343 SoftBusFree(data);
344 }
345
346 /**
347 * @tc.name: ClientIpcOnChannelOpenFailedTest002
348 * @tc.desc: ClientIpcOnChannelOpenFailed test.
349 * @tc.type: FUNC
350 * @tc.require:
351 */
352 HWTEST_F(TransClientProxyTest, ClientIpcOnChannelOpenFailedTest002, TestSize.Level1)
353 {
354 ChannelMsg *data = nullptr;
355 int32_t errCode = 0;
356 int32_t ret = ClientIpcOnChannelOpenFailed(data, errCode);
357 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
358
359 data = (ChannelMsg *)SoftBusCalloc(sizeof(ChannelMsg));
360 ASSERT_NE(nullptr, data);
361 data->msgPid = TEST_PID;
362 ret = ClientIpcOnChannelOpenFailed(data, errCode);
363 EXPECT_EQ(SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL, ret);
364 SoftBusFree(data);
365 }
366
367 /**
368 * @tc.name: ClientIpcOnChannelLinkDownTest002
369 * @tc.desc: ClientIpcOnChannelLinkDown test.
370 * @tc.type: FUNC
371 * @tc.require:
372 */
373 HWTEST_F(TransClientProxyTest, ClientIpcOnChannelLinkDownTest002, TestSize.Level1)
374 {
375 const char *peerIp = "1234"; // test value
376 int32_t routeType = TEST_REMOTE_TYPE;
377 int32_t ret = ClientIpcOnChannelLinkDown(nullptr, nullptr, peerIp, routeType);
378 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
379
380 const char *networkId = "1234"; // test value
381 ChannelMsg *data = (ChannelMsg *)SoftBusCalloc(sizeof(ChannelMsg));
382 ASSERT_NE(nullptr, data);
383 ret = ClientIpcOnChannelLinkDown(data, networkId, peerIp, routeType);
384 EXPECT_EQ(SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL, ret);
385 SoftBusFree(data);
386 data = nullptr;
387 }
388
389 /**
390 * @tc.name: ClientIpcOnChannelClosedTest002
391 * @tc.desc: ClientIpcOnChannelClosed test.
392 * @tc.type: FUNC
393 * @tc.require:
394 */
395 HWTEST_F(TransClientProxyTest, ClientIpcOnChannelClosedTest002, TestSize.Level1)
396 {
397 ChannelMsg *data = nullptr;
398 int32_t ret = ClientIpcOnChannelClosed(data);
399 EXPECT_EQ(SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL, ret);
400
401 data = (ChannelMsg *)SoftBusCalloc(sizeof(ChannelMsg));
402 ASSERT_NE(nullptr, data);
403 data->msgPid = TEST_PID;
404 ret = ClientIpcOnChannelClosed(data);
405 EXPECT_EQ(SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL, ret);
406 SoftBusFree(data);
407 }
408
409 /**
410 * @tc.name: ClientIpcSetChannelInfoTest001
411 * @tc.desc: ClientIpcSetChannelInfo test.
412 * @tc.type: FUNC
413 * @tc.require:
414 */
415 HWTEST_F(TransClientProxyTest, ClientIpcSetChannelInfoTest001, TestSize.Level1)
416 {
417 int32_t sessionId = TEST_PID;
418 int32_t pid = TEST_PID;
419 int32_t ret = ClientIpcSetChannelInfo(nullptr, nullptr, sessionId, nullptr, pid);
420 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
421
422 TransInfo *transInfo = (TransInfo *)SoftBusCalloc(sizeof(TransInfo));
423 ASSERT_NE(nullptr, transInfo);
424 transInfo->channelId = TEST_CHANNELID;
425 transInfo->channelType = TEST_CHANNELTYPE;
426 ret = ClientIpcSetChannelInfo("iShare", "HWiShare", sessionId, transInfo, pid);
427 EXPECT_EQ(SOFTBUS_TRANS_PROXY_REMOTE_NULL, ret);
428
429 static const uint32_t SOFTBUS_SA_ID = 4700;
430 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
431 ASSERT_TRUE(saManager != nullptr);
432 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
433 ASSERT_TRUE(remoteObject != nullptr);
434 sptr<IRemoteObject::DeathRecipient> abilityDeath = new (std::nothrow) SoftBusDeathRecipient();
435 ASSERT_TRUE(abilityDeath != nullptr);
436 ret = SoftbusClientInfoManager::GetInstance().SoftbusAddService(g_pkgName, remoteObject, abilityDeath, TEST_PID);
437 EXPECT_EQ(SOFTBUS_OK, ret);
438
439 ret = ClientIpcSetChannelInfo(g_pkgName, g_sessionName, sessionId, transInfo, pid);
440 EXPECT_EQ(SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED, ret);
441 SoftBusFree(transInfo);
442 }
443
444 /**
445 * @tc.name: ClientIpcOnChannelMsgReceivedTest002
446 * @tc.desc: ClientIpcOnChannelMsgReceived test.
447 * @tc.type: FUNC
448 * @tc.require:
449 */
450 HWTEST_F(TransClientProxyTest, ClientIpcOnChannelMsgReceivedTest002, TestSize.Level1)
451 {
452 int32_t ret = ClientIpcOnChannelMsgReceived(nullptr, nullptr);
453 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
454
455 ChannelMsg *data = (ChannelMsg *)SoftBusCalloc(sizeof(ChannelMsg));
456 ASSERT_NE(nullptr, data);
457 data->msgChannelId = TEST_CHANNELID;
458 data->msgChannelType = TEST_CHANNELTYPE;
459 data->msgPkgName = "iShare";
460 data->msgPid = TEST_PID;
461 data->msgMessageType = TEST_CHANNELTYPE;
462
463 TransReceiveData *receiveData = (TransReceiveData *)SoftBusCalloc(sizeof(TransReceiveData));
464 ASSERT_NE(nullptr, receiveData);
465 receiveData->dataLen = TEST_LEN;
466 receiveData->dataType = TEST_DATA_TYPE;
467 ret = ClientIpcOnChannelMsgReceived(data, receiveData);
468 EXPECT_EQ(SOFTBUS_OK, ret);
469 SoftBusFree(data);
470 SoftBusFree(receiveData);
471 }
472
473 /**
474 * @tc.name: ClientIpcOnTransLimitChangeTest001
475 * @tc.desc: ClientIpcOnTransLimitChange test.
476 * @tc.type: FUNC
477 * @tc.require:
478 */
479 HWTEST_F(TransClientProxyTest, ClientIpcOnTransLimitChangeTest001, TestSize.Level1)
480 {
481 uint8_t tos = 0;
482 int32_t ret = ClientIpcOnTransLimitChange(nullptr, TEST_PID, TEST_CHANNELID, tos);
483 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
484
485 ret = ClientIpcOnTransLimitChange(g_pkgName, 1, TEST_CHANNELID, tos);
486 EXPECT_NE(SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL, ret);
487
488 ret = ClientIpcOnTransLimitChange(g_pkgName, TEST_PID, TEST_CHANNELID, tos);
489 EXPECT_EQ(SOFTBUS_OK, ret);
490 }
491
492 /**
493 * @tc.name: CheckServiceIsRegisteredTest001
494 * @tc.desc: CheckServiceIsRegistered test.
495 * @tc.type: FUNC
496 * @tc.require:
497 */
498 HWTEST_F(TransClientProxyTest, CheckServiceIsRegisteredTest001, TestSize.Level1)
499 {
500 int32_t ret = CheckServiceIsRegistered(nullptr, TEST_PID);
501 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
502
503 ret = CheckServiceIsRegistered(g_pkgName, TEST_PID);
504 EXPECT_EQ(SOFTBUS_OK, ret);
505 }
506
507 /**
508 * @tc.name: ClientIpcChannelOnQosTest001
509 * @tc.desc: ClientIpcChannelOnQos test.
510 * @tc.type: FUNC
511 * @tc.require:
512 */
513 HWTEST_F(TransClientProxyTest, ClientIpcChannelOnQosTest001, TestSize.Level1)
514 {
515 int32_t ret = ClientIpcChannelOnQos(nullptr, QOS_SATISFIED, nullptr, QOS_TYPE_BUTT);
516 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
517
518 ChannelMsg data;
519 data.msgPkgName = nullptr;
520 ret = ClientIpcChannelOnQos(&data, QOS_SATISFIED, nullptr, QOS_TYPE_BUTT);
521 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
522
523 data.msgPkgName = g_pkgName;
524 ret = ClientIpcChannelOnQos(&data, QOS_SATISFIED, nullptr, QOS_TYPE_BUTT);
525 QosTV qos[] = {
526 {QOS_TYPE_MIN_BW, 0},
527 };
528 ret = ClientIpcChannelOnQos(&data, QOS_SATISFIED, qos, QOS_TYPE_BUTT);
529 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
530
531 ret = ClientIpcChannelOnQos(&data, QOS_SATISFIED, qos, 1);
532 EXPECT_NE(SOFTBUS_OK, ret);
533
534 data.msgChannelId = TEST_CHANNELID;
535 data.msgChannelType = TEST_CHANNELTYPE;
536 data.msgPid = TEST_PID;
537 ret = ClientIpcChannelOnQos(&data, QOS_SATISFIED, qos, 1);
538 EXPECT_EQ(SOFTBUS_OK, ret);
539 }
540
541 /**
542 * @tc.name: ClientIpcCheckCollabRelationTest001
543 * @tc.desc: ClientIpcCheckCollabRelation test.
544 * @tc.type: FUNC
545 * @tc.require:
546 */
547 HWTEST_F(TransClientProxyTest, ClientIpcCheckCollabRelationTest001, TestSize.Level1)
548 {
549 int32_t pid = 0;
550 CollabInfo sourceInfo = {
551 .accountId = "",
552 .deviceId = "ABCDE",
553 .pid = 0,
554 .tokenId = 0,
555 .userId = 0,
556 };
557 CollabInfo sinkInfo = {
558 .accountId = "",
559 .deviceId = "ABCDE",
560 .pid = 0,
561 .tokenId = 0,
562 .userId = 0,
563 };
564 TransInfo transInfo = {
565 .channelId = 0,
566 .channelType = 0,
567 };
568 int32_t ret = ClientIpcCheckCollabRelation(nullptr, pid, &sourceInfo, &sinkInfo, &transInfo);
569 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
570
571 ret = ClientIpcCheckCollabRelation(g_pkgName, pid, &sourceInfo, &sinkInfo, &transInfo);
572 EXPECT_EQ(SOFTBUS_TRANS_PROXY_REMOTE_NULL, ret);
573 }
574
575 /**
576 * @tc.name: ClientIpcCheckParamTest001
577 * @tc.desc: ClientIpcCheckParam test.
578 * @tc.type: FUNC
579 * @tc.require:
580 */
581 HWTEST_F(TransClientProxyTest, ClientIpcCheckParamTest001, TestSize.Level1)
582 {
583 int32_t pid = 0;
584 int32_t ret = ClientIpcOnChannelOpened(nullptr, nullptr, nullptr, pid);
585 EXPECT_EQ(SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL, ret);
586
587 int32_t errCode = 0;
588 ret = ClientIpcOnChannelOpenFailed(nullptr, errCode);
589 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
590
591 ChannelMsg *data;
592 data = (ChannelMsg *)SoftBusCalloc(sizeof(ChannelMsg));
593 ASSERT_NE(nullptr, data);
594 data->msgPkgName = nullptr;
595 ret = ClientIpcOnChannelOpenFailed(data, errCode);
596 EXPECT_EQ(SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL, ret);
597
598 const char *peerIp = "1234";
599 int32_t routeType = TEST_REMOTE_TYPE;
600 const char *networkId = "1234";
601 ret = ClientIpcOnChannelLinkDown(nullptr, networkId, peerIp, routeType);
602 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
603
604 ret = ClientIpcOnChannelLinkDown(data, networkId, peerIp, routeType);
605 EXPECT_EQ(SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL, ret);
606
607 ret = ClientIpcOnChannelClosed(nullptr);
608 EXPECT_EQ(SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL, ret);
609
610 ret = ClientIpcOnChannelClosed(data);
611 EXPECT_EQ(SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL, ret);
612
613 ret = ClientIpcOnChannelMsgReceived(nullptr, nullptr);
614 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
615
616 TransReceiveData *receiveData = (TransReceiveData *)SoftBusCalloc(sizeof(TransReceiveData));
617 ASSERT_NE(nullptr, receiveData);
618 receiveData->dataLen = TEST_LEN;
619 receiveData->dataType = TEST_DATA_TYPE;
620 ret = ClientIpcOnChannelMsgReceived(data, receiveData);
621 EXPECT_EQ(SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL, ret);
622 SoftBusFree(receiveData);
623 SoftBusFree(data);
624
625 QosParam param;
626 param.pid = TEST_PID;
627 ret = ClientIpcOnChannelQosEvent(nullptr, ¶m);
628 EXPECT_EQ(SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL, ret);
629 }
630
631 /**
632 * @tc.name: ClientIpcBrProxyOpenedTest001
633 * @tc.desc: ClientIpcBrProxyOpened test.
634 * @tc.type: FUNC
635 * @tc.require:
636 */
637 HWTEST_F(TransClientProxyTest, ClientIpcBrProxyOpenedTest001, TestSize.Level1)
638 {
639 int32_t channelId = 1;
640 int32_t reason = 1;
641
642 int32_t ret = ClientIpcBrProxyOpened(nullptr, channelId, nullptr, nullptr, reason);
643 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
644
645 const char *pkgName = "testName";
646 ret = ClientIpcBrProxyOpened(pkgName, channelId, nullptr, nullptr, reason);
647 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
648
649 const char *uuid = "testUuid";
650 ret = ClientIpcBrProxyOpened(nullptr, channelId, nullptr, uuid, reason);
651 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
652
653 const char *brMac = "11:22:33:44"; // test value
654 ret = ClientIpcBrProxyOpened(nullptr, channelId, brMac, nullptr, reason);
655 EXPECT_NE(SOFTBUS_OK, ret);
656 }
657
658 /**
659 * @tc.name: ClientIpcBrProxyReceivedDataTest001
660 * @tc.desc: ClientIpcBrProxyReceivedData test.
661 * @tc.type: FUNC
662 * @tc.require:
663 */
664 HWTEST_F(TransClientProxyTest, ClientIpcBrProxyReceivedDataTest001, TestSize.Level1)
665 {
666 int32_t channelId = 1;
667 uint32_t len = 1;
668
669 int32_t ret = ClientIpcBrProxyReceivedData(nullptr, channelId, nullptr, len);
670 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
671
672 const char *pkgName = "testName";
673 ret = ClientIpcBrProxyReceivedData(pkgName, channelId, nullptr, len);
674 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
675
676 uint8_t data = 1;
677 ret = ClientIpcBrProxyReceivedData(pkgName, channelId, &data, len);
678 EXPECT_NE(SOFTBUS_INVALID_PARAM, ret);
679 }
680
681 /**
682 * @tc.name: ClientIpcBrProxyStateChangedTest001
683 * @tc.desc: ClientIpcBrProxyStateChanged test.
684 * @tc.type: FUNC
685 * @tc.require:
686 */
687 HWTEST_F(TransClientProxyTest, ClientIpcBrProxyStateChangedTest001, TestSize.Level1)
688 {
689 int32_t channelId = 1;
690 int32_t channelState = 1;
691
692 int32_t ret = ClientIpcBrProxyStateChanged(nullptr, channelId, channelState);
693 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
694
695 const char *pkgName = "testName";
696 ret = ClientIpcBrProxyStateChanged(pkgName, channelId, channelState);
697 EXPECT_NE(SOFTBUS_INVALID_PARAM, ret);
698 }
699
700 /**
701 * @tc.name: ClientIpcQueryPermissionTest001
702 * @tc.desc: ClientIpcQueryPermission test.
703 * @tc.type: FUNC
704 * @tc.require:
705 */
706 HWTEST_F(TransClientProxyTest, ClientIpcQueryPermissionTest001, TestSize.Level1)
707 {
708 int32_t ret = ClientIpcQueryPermission(nullptr, nullptr, nullptr);
709 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
710
711 const char *pkgName = "testName";
712 ret = ClientIpcQueryPermission(pkgName, nullptr, nullptr);
713 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
714
715 const char *bundleName = "testName";
716 ret = ClientIpcQueryPermission(pkgName, bundleName, nullptr);
717 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
718
719 bool isEmpowered = true;
720 ret = ClientIpcQueryPermission(pkgName, bundleName, &isEmpowered);
721 EXPECT_NE(SOFTBUS_INVALID_PARAM, ret);
722 }
723 } // namespace OHOS
724