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.Level0)
75 {
76 int32_t ret;
77
78 ret = InformPermissionChange(TEST_STATE, nullptr, TEST_PID);
79 EXPECT_EQ(SOFTBUS_INVALID_PKGNAME, 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.Level0)
103 {
104 int32_t ret;
105 ChannelInfo channel;
106 char strTmp[] = "ABCDEFG";
107 channel.channelId = TEST_CHANNELID;
108 channel.channelType = TEST_CHANNELTYPE;
109 channel.fd = TEST_DATA_TYPE;
110 channel.isServer = true;
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_EQ(SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED, 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_EQ(SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED, ret);
143
144 channel.isServer = false;
145 ret = ClientIpcOnChannelOpened(g_pkgName, g_sessionName, &channel, TEST_PID);
146 EXPECT_EQ(SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED, 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.Level0)
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.Level0)
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, NULL, 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, NULL, 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.Level0)
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.Level0)
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.Level0)
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.Level0)
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 SoftBusFree(data);
330 }
331
332 /**
333 * @tc.name: ClientIpcOnChannelOpenFailedTest002
334 * @tc.desc: ClientIpcOnChannelOpenFailed test.
335 * @tc.type: FUNC
336 * @tc.require:
337 */
338 HWTEST_F(TransClientProxyTest, ClientIpcOnChannelOpenFailedTest002, TestSize.Level0)
339 {
340 ChannelMsg *data = nullptr;
341 int32_t errCode = 0;
342 int32_t ret = ClientIpcOnChannelOpenFailed(data, errCode);
343 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
344
345 data = (ChannelMsg *)SoftBusCalloc(sizeof(ChannelMsg));
346 ASSERT_NE(nullptr, data);
347 data->msgPid = TEST_PID;
348 ret = ClientIpcOnChannelOpenFailed(data, errCode);
349 EXPECT_EQ(SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL, ret);
350 SoftBusFree(data);
351 }
352
353 /**
354 * @tc.name: ClientIpcOnChannelLinkDownTest002
355 * @tc.desc: ClientIpcOnChannelLinkDown test.
356 * @tc.type: FUNC
357 * @tc.require:
358 */
359 HWTEST_F(TransClientProxyTest, ClientIpcOnChannelLinkDownTest002, TestSize.Level0)
360 {
361 const char *peerIp = "1234"; // test value
362 int32_t routeType = TEST_REMOTE_TYPE;
363 int32_t ret = ClientIpcOnChannelLinkDown(nullptr, nullptr, peerIp, routeType);
364 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
365
366 const char *networkId = "1234"; // test value
367 ChannelMsg *data = (ChannelMsg *)SoftBusCalloc(sizeof(ChannelMsg));
368 ASSERT_NE(nullptr, data);
369 ret = ClientIpcOnChannelLinkDown(data, networkId, peerIp, routeType);
370 EXPECT_EQ(SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL, ret);
371 SoftBusFree(data);
372 data = nullptr;
373 }
374
375 /**
376 * @tc.name: ClientIpcOnChannelClosedTest002
377 * @tc.desc: ClientIpcOnChannelClosed test.
378 * @tc.type: FUNC
379 * @tc.require:
380 */
381 HWTEST_F(TransClientProxyTest, ClientIpcOnChannelClosedTest002, TestSize.Level0)
382 {
383 ChannelMsg *data = nullptr;
384 int32_t ret = ClientIpcOnChannelClosed(data);
385 EXPECT_EQ(SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL, ret);
386
387 data = (ChannelMsg *)SoftBusCalloc(sizeof(ChannelMsg));
388 ASSERT_NE(nullptr, data);
389 data->msgPid = TEST_PID;
390 ret = ClientIpcOnChannelClosed(data);
391 EXPECT_EQ(SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL, ret);
392 SoftBusFree(data);
393 }
394
395 /**
396 * @tc.name: ClientIpcSetChannelInfoTest001
397 * @tc.desc: ClientIpcSetChannelInfo test.
398 * @tc.type: FUNC
399 * @tc.require:
400 */
401 HWTEST_F(TransClientProxyTest, ClientIpcSetChannelInfoTest001, TestSize.Level0)
402 {
403 int32_t sessionId = TEST_PID;
404 int32_t pid = TEST_PID;
405 int32_t ret = ClientIpcSetChannelInfo(nullptr, nullptr, sessionId, nullptr, pid);
406 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
407
408 TransInfo *transInfo = (TransInfo *)SoftBusCalloc(sizeof(TransInfo));
409 ASSERT_NE(nullptr, transInfo);
410 transInfo->channelId = TEST_CHANNELID;
411 transInfo->channelType = TEST_CHANNELTYPE;
412 ret = ClientIpcSetChannelInfo("iShare", "HWiShare", sessionId, transInfo, pid);
413 EXPECT_EQ(SOFTBUS_TRANS_PROXY_REMOTE_NULL, ret);
414 SoftBusFree(transInfo);
415 }
416
417 /**
418 * @tc.name: ClientIpcOnChannelMsgReceivedTest002
419 * @tc.desc: ClientIpcOnChannelMsgReceived test.
420 * @tc.type: FUNC
421 * @tc.require:
422 */
423 HWTEST_F(TransClientProxyTest, ClientIpcOnChannelMsgReceivedTest002, TestSize.Level0)
424 {
425 int32_t ret = ClientIpcOnChannelMsgReceived(nullptr, nullptr);
426 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
427
428 ChannelMsg *data = (ChannelMsg *)SoftBusCalloc(sizeof(ChannelMsg));
429 ASSERT_NE(nullptr, data);
430 data->msgChannelId = TEST_CHANNELID;
431 data->msgChannelType = TEST_CHANNELTYPE;
432 data->msgPkgName = "iShare";
433 data->msgPid = TEST_PID;
434 data->msgMessageType = TEST_CHANNELTYPE;
435
436 TransReceiveData *receiveData = (TransReceiveData *)SoftBusCalloc(sizeof(TransReceiveData));
437 ASSERT_NE(nullptr, receiveData);
438 receiveData->dataLen = TEST_LEN;
439 receiveData->dataType = TEST_DATA_TYPE;
440 ret = ClientIpcOnChannelMsgReceived(data, receiveData);
441 EXPECT_EQ(SOFTBUS_OK, ret);
442 SoftBusFree(data);
443 SoftBusFree(receiveData);
444 }
445
446 /**
447 * @tc.name: ClientIpcOnTransLimitChangeTest001
448 * @tc.desc: ClientIpcOnTransLimitChange test.
449 * @tc.type: FUNC
450 * @tc.require:
451 */
452 HWTEST_F(TransClientProxyTest, ClientIpcOnTransLimitChangeTest001, TestSize.Level0)
453 {
454 uint8_t tos = 0;
455 int32_t ret = ClientIpcOnTransLimitChange(nullptr, TEST_PID, TEST_CHANNELID, tos);
456 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
457
458 ret = ClientIpcOnTransLimitChange(g_pkgName, TEST_PID, TEST_CHANNELID, tos);
459 EXPECT_NE(SOFTBUS_OK, ret);
460 }
461
462 /**
463 * @tc.name: CheckServiceIsRegisteredTest001
464 * @tc.desc: CheckServiceIsRegistered test.
465 * @tc.type: FUNC
466 * @tc.require:
467 */
468 HWTEST_F(TransClientProxyTest, CheckServiceIsRegisteredTest001, TestSize.Level0)
469 {
470 int32_t ret = CheckServiceIsRegistered(nullptr, TEST_PID);
471 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
472
473 ret = CheckServiceIsRegistered(g_pkgName, TEST_PID);
474 EXPECT_EQ(SOFTBUS_OK, ret);
475 }
476
477 /**
478 * @tc.name: ClientIpcChannelOnQosTest001
479 * @tc.desc: ClientIpcChannelOnQos test.
480 * @tc.type: FUNC
481 * @tc.require:
482 */
483 HWTEST_F(TransClientProxyTest, ClientIpcChannelOnQosTest001, TestSize.Level0)
484 {
485 int32_t ret = ClientIpcChannelOnQos(nullptr, QOS_SATISFIED, nullptr, QOS_TYPE_BUTT);
486 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
487
488 ChannelMsg data;
489 data.msgPkgName = nullptr;
490 ret = ClientIpcChannelOnQos(&data, QOS_SATISFIED, nullptr, QOS_TYPE_BUTT);
491 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
492
493 data.msgPkgName = g_pkgName;
494 ret = ClientIpcChannelOnQos(&data, QOS_SATISFIED, nullptr, QOS_TYPE_BUTT);
495 QosTV qos[] = {
496 {QOS_TYPE_MIN_BW, 0},
497 };
498 ret = ClientIpcChannelOnQos(&data, QOS_SATISFIED, qos, QOS_TYPE_BUTT);
499 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
500
501 ret = ClientIpcChannelOnQos(&data, QOS_SATISFIED, qos, 1);
502 EXPECT_NE(SOFTBUS_OK, ret);
503
504 data.msgChannelId = TEST_CHANNELID;
505 data.msgChannelType = TEST_CHANNELTYPE;
506 data.msgPid = TEST_PID;
507 ret = ClientIpcChannelOnQos(&data, QOS_SATISFIED, qos, 1);
508 EXPECT_EQ(SOFTBUS_OK, ret);
509 }
510 } // namespace OHOS