1 /*
2 * Copyright (c) 2023-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 #include <gtest/gtest.h>
16 #include <securec.h>
17
18 #include "softbus_client_death_recipient.cpp"
19 #include "softbus_client_frame_manager.h"
20 #define private public
21 #define protected public
22 #include "softbus_client_stub.cpp"
23 #include "softbus_client_stub.h"
24 #undef private
25 #undef protected
26 #include "softbus_server_proxy_frame.cpp"
27 #include "softbus_server_proxy_standard.h"
28
29 using namespace std;
30 using namespace testing::ext;
31 using namespace OHOS;
32
33 namespace OHOS {
34 class SoftBusServerProxyFrameTest : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 };
39
40 class SoftBusClientDeathRecipientMock : public SoftBusClientDeathRecipient {
41 public:
OnRemoteDied(const wptr<IRemoteObject> & remote)42 void OnRemoteDied(const wptr<IRemoteObject> &remote) override { }
43 };
44
45 class SoftBusClientStubMock : public SoftBusClientStub {
46 public:
OnPublishLNNResult(int32_t publishId,int32_t reason)47 void OnPublishLNNResult(int32_t publishId, int32_t reason) override { }
OnRefreshLNNResult(int32_t refreshId,int32_t reason)48 void OnRefreshLNNResult(int32_t refreshId, int32_t reason) override { }
OnRefreshDeviceFound(const void * device,uint32_t deviceLen)49 void OnRefreshDeviceFound(const void *device, uint32_t deviceLen) override { }
OnDataLevelChanged(const char * networkId,const DataLevelInfo * dataLevelInfo)50 void OnDataLevelChanged(const char *networkId, const DataLevelInfo *dataLevelInfo) override { }
OnChannelQosEvent(int32_t channelId,int32_t channelType,int32_t eventId,int32_t tvCount,const QosTv * tvList)51 int32_t OnChannelQosEvent(int32_t channelId, int32_t channelType, int32_t eventId, int32_t tvCount,
52 const QosTv *tvList) override
53 {
54 return SOFTBUS_OK;
55 }
OnChannelOpened(const char * sessionName,const ChannelInfo * info)56 int32_t OnChannelOpened(const char *sessionName, const ChannelInfo *info) override
57 {
58 return SOFTBUS_OK;
59 }
OnJoinLNNResult(void * addr,uint32_t addrTypeLen,const char * networkId,int retCode)60 int32_t OnJoinLNNResult(void *addr, uint32_t addrTypeLen, const char *networkId, int retCode) override
61 {
62 return SOFTBUS_OK;
63 }
OnNodeOnlineStateChanged(const char * pkgName,bool isOnline,void * info,uint32_t infoTypeLen)64 int32_t OnNodeOnlineStateChanged(const char *pkgName, bool isOnline, void *info, uint32_t infoTypeLen) override
65 {
66 return SOFTBUS_OK;
67 }
OnNodeBasicInfoChanged(const char * pkgName,void * info,uint32_t infoTypeLen,int32_t type)68 int32_t OnNodeBasicInfoChanged(const char *pkgName, void *info, uint32_t infoTypeLen, int32_t type) override
69 {
70 return SOFTBUS_OK;
71 }
OnLocalNetworkIdChanged(const char * pkgName)72 int32_t OnLocalNetworkIdChanged(const char *pkgName) override
73 {
74 return SOFTBUS_OK;
75 }
OnTimeSyncResult(const void * info,uint32_t infoTypeLen,int32_t retCode)76 int32_t OnTimeSyncResult(const void *info, uint32_t infoTypeLen, int32_t retCode) override
77 {
78 return SOFTBUS_OK;
79 }
OnClientTransLimitChange(int32_t channelId,uint8_t tos)80 int32_t OnClientTransLimitChange(int32_t channelId, uint8_t tos) override
81 {
82 return SOFTBUS_OK;
83 }
OnChannelOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)84 int32_t OnChannelOpenFailed([[maybe_unused]] int32_t channelId, [[maybe_unused]] int32_t channelType,
85 [[maybe_unused]] int32_t errCode) override
86 {
87 return SOFTBUS_OK;
88 }
OnChannelBind(int32_t channelId,int32_t channelType)89 int32_t OnChannelBind([[maybe_unused]] int32_t channelId, [[maybe_unused]] int32_t channelType) override
90 {
91 return SOFTBUS_OK;
92 }
OnChannelLinkDown(const char * networkId,int32_t routeType)93 int32_t OnChannelLinkDown([[maybe_unused]] const char *networkId, [[maybe_unused]] int32_t routeType) override
94 {
95 return SOFTBUS_OK;
96 }
OnChannelClosed(int32_t channelId,int32_t channelType,int32_t messageType)97 int32_t OnChannelClosed([[maybe_unused]] int32_t channelId, [[maybe_unused]] int32_t channelType,
98 [[maybe_unused]] int32_t messageType) override
99 {
100 return SOFTBUS_OK;
101 }
OnChannelMsgReceived(int32_t channelId,int32_t channelType,const void * data,uint32_t len,int32_t type)102 int32_t OnChannelMsgReceived([[maybe_unused]] int32_t channelId, [[maybe_unused]] int32_t channelType,
103 [[maybe_unused]] const void *data, [[maybe_unused]] uint32_t len, [[maybe_unused]] int32_t type) override
104 {
105 return SOFTBUS_OK;
106 }
SetChannelInfo(const char * sessionName,int32_t sessionId,int32_t channelId,int32_t channelType)107 int32_t SetChannelInfo([[maybe_unused]]const char *sessionName, [[maybe_unused]] int32_t sessionId,
108 [[maybe_unused]] int32_t channelId, [[maybe_unused]] int32_t channelType) override
109 {
110 return SOFTBUS_OK;
111 }
OnConnectionStateChange(uint32_t handle,int32_t state,int32_t reason)112 int32_t OnConnectionStateChange(
113 [[maybe_unused]] uint32_t handle, [[maybe_unused]] int32_t state, [[maybe_unused]] int32_t reason) override
114 {
115 return SOFTBUS_OK;
116 }
OnAcceptConnect(const char * name,uint32_t handle)117 int32_t OnAcceptConnect([[maybe_unused]] const char *name, [[maybe_unused]] uint32_t handle) override
118 {
119 return SOFTBUS_OK;
120 }
OnDataReceived(uint32_t handle,const uint8_t * data,uint32_t len)121 int32_t OnDataReceived(
122 [[maybe_unused]] uint32_t handle, [[maybe_unused]] const uint8_t *data, [[maybe_unused]] uint32_t len) override
123 {
124 return SOFTBUS_OK;
125 }
126 };
127
128 namespace {
129 sptr<SoftBusClientStubMock> g_stub = nullptr;
130 sptr<SoftBusClientDeathRecipientMock> g_mock = nullptr;
131 }
132
SetUpTestCase()133 void SoftBusServerProxyFrameTest::SetUpTestCase()
134 {
135 g_stub = new (std::nothrow) SoftBusClientStubMock();
136 g_mock = new (std::nothrow) SoftBusClientDeathRecipientMock();
137 }
138
TearDownTestCase()139 void SoftBusServerProxyFrameTest::TearDownTestCase()
140 {
141 g_stub = nullptr;
142 g_mock = nullptr;
143 }
144
145 /**
146 * @tc.name: InnerRegisterServiceTest
147 * @tc.desc: InnerRegisterServiceTest, Initialization failure
148 * @tc.desc: InnerRegisterServiceTest, Successful initialization
149 * @tc.type: FUNC
150 * @tc.require:
151 */
152 HWTEST_F(SoftBusServerProxyFrameTest, InnerRegisterServiceTest, TestSize.Level1)
153 {
154 EXPECT_EQ(InnerRegisterService(nullptr), SOFTBUS_INVALID_PARAM);
155
156 EXPECT_EQ(ServerProxyInit(), SOFTBUS_OK);
157 EXPECT_EQ(InitSoftBus("SoftBusServerProxyFrameTest"), SOFTBUS_NO_INIT);
158 EXPECT_EQ(InnerRegisterService(nullptr), SOFTBUS_TRANS_GET_CLIENT_NAME_FAILED);
159
160 ListNode sessionServerList;
161 ListInit(&sessionServerList);
162 EXPECT_EQ(InnerRegisterService(&sessionServerList), SOFTBUS_TRANS_GET_CLIENT_NAME_FAILED);
163 }
164
165 /**
166 * @tc.name: GetSystemAbilityTest
167 * @tc.desc: GetSystemAbilityTest, Get interface return is not empty
168 * @tc.type: FUNC
169 * @tc.require:
170 */
171 HWTEST_F(SoftBusServerProxyFrameTest, GetSystemAbilityTest, TestSize.Level1)
172 {
173 EXPECT_TRUE(GetSystemAbility() != nullptr);
174 }
175
176 /**
177 * @tc.name: ClientRegisterServiceTest
178 * @tc.desc: ClientRegisterServiceTest, Initializing registration succeeded. Procedure
179 * @tc.type: FUNC
180 * @tc.require:
181 */
182 HWTEST_F(SoftBusServerProxyFrameTest, ClientRegisterServiceTest, TestSize.Level1)
183 {
184 EXPECT_EQ(ServerProxyInit(), SOFTBUS_OK);
185 EXPECT_EQ(ClientRegisterService("ClientRegisterServiceTest"), SOFTBUS_SERVER_NOT_INIT);
186 }
187
188 /**
189 * @tc.name: ClientStubInitTest
190 * @tc.desc: ClientStubInitTest, Successful initialization
191 * @tc.type: FUNC
192 * @tc.require:
193 */
194 HWTEST_F(SoftBusServerProxyFrameTest, ClientStubInitTest, TestSize.Level1)
195 {
196 EXPECT_EQ(ClientStubInit(), SOFTBUS_OK);
197 }
198
199 /**
200 * @tc.name: SoftbusRegisterServiceTest
201 * @tc.desc: SoftbusRegisterServiceTest, remote is nullptr return SOFTBUS_ERR
202 * @tc.desc: SoftbusRegisterServiceTest, SoftbusRegisterService success return SOFTBUS_OK
203 * @tc.desc: SoftbusRegisterServiceTest, clientPkgName is nullptr return SOFTBUS_ERR
204 * @tc.type: FUNC
205 * @tc.require:
206 */
207 HWTEST_F(SoftBusServerProxyFrameTest, SoftbusRegisterServiceTest, TestSize.Level1)
208 {
209 sptr<SoftBusServerProxyFrame> serverProxyFrame = new (std::nothrow) SoftBusServerProxyFrame(nullptr);
210 ASSERT_TRUE(serverProxyFrame != nullptr);
211 EXPECT_EQ(serverProxyFrame->SoftbusRegisterService("SoftbusRegisterServiceTest", nullptr), SOFTBUS_IPC_ERR);
212
213 sptr<IRemoteObject> serverProxy = GetSystemAbility();
214 ASSERT_TRUE(serverProxy != nullptr);
215 serverProxyFrame = new (std::nothrow) SoftBusServerProxyFrame(serverProxy);
216 ASSERT_TRUE(serverProxyFrame != nullptr);
217 EXPECT_EQ(serverProxyFrame->SoftbusRegisterService("SoftbusRegisterServiceTest", nullptr), SOFTBUS_IPC_ERR);
218
219 EXPECT_EQ(serverProxyFrame->SoftbusRegisterService(nullptr, nullptr), SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED);
220 }
221
222 /**
223 * @tc.name: OnRemoteRequestTest
224 * @tc.desc: OnRemoteRequestTest, ReadInterfaceToken faild return SOFTBUS_ERR
225 * @tc.desc: OnRemoteRequestTest, OnRemoteRequest Call default return IPC_STUB_UNKNOW_TRANS_ERR
226 * @tc.desc: OnRemoteRequestTest, OnRemoteRequest Call CLIENT_ON_PERMISSION_CHANGE
227 * @tc.type: FUNC
228 * @tc.require:
229 */
230 HWTEST_F(SoftBusServerProxyFrameTest, OnRemoteRequestTest, TestSize.Level1)
231 {
232 ASSERT_TRUE(g_stub != nullptr);
233 uint32_t code = 0;
234 MessageParcel data;
235 MessageParcel reply;
236 MessageOption option;
237 EXPECT_EQ(g_stub->OnRemoteRequest(code, data, reply, option), SOFTBUS_TRANS_PROXY_READTOKEN_FAILED);
238
239 data.WriteInterfaceToken(g_stub->GetDescriptor());
240 EXPECT_EQ(g_stub->OnRemoteRequest(code, data, reply, option), IPC_STUB_UNKNOW_TRANS_ERR);
241
242 code = CLIENT_ON_PERMISSION_CHANGE;
243 data.WriteInterfaceToken(g_stub->GetDescriptor());
244 data.WriteInt32(0);
245 data.WriteCString("OnRemoteRequestTest");
246 EXPECT_EQ(g_stub->OnRemoteRequest(code, data, reply, option), SOFTBUS_OK);
247 }
248
249 /**
250 * @tc.name: OnClientPermissonChangeInnerTest
251 * @tc.desc: OnClientPermissonChangeInnerTest, ReadInt32 faild return SOFTBUS_ERR
252 * @tc.desc: OnClientPermissonChangeInnerTest, ReadCString faild return SOFTBUS_ERR
253 * @tc.desc: OnClientPermissonChangeInnerTest, success return SOFTBUS_OK
254 * @tc.type: FUNC
255 * @tc.require:
256 */
257 HWTEST_F(SoftBusServerProxyFrameTest, OnClientPermissonChangeInnerTest, TestSize.Level1)
258 {
259 ASSERT_TRUE(g_stub != nullptr);
260 MessageParcel data;
261 MessageParcel reply;
262 EXPECT_EQ(g_stub->OnClientPermissonChangeInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
263
264 data.WriteInt32(0);
265 EXPECT_EQ(g_stub->OnClientPermissonChangeInner(data, reply), SOFTBUS_TRANS_PROXY_READCSTRING_FAILED);
266
267 data.WriteInt32(0);
268 data.WriteCString("OnClientPermissonChangeInnerTest");
269 EXPECT_EQ(g_stub->OnClientPermissonChangeInner(data, reply), SOFTBUS_OK);
270 }
271
272 /**
273 * @tc.name: OnClientTransLimitChangeInnerTest
274 * @tc.desc: OnClientTransLimitChangeInnerTest, ReadInt32 faild return SOFTBUS_ERR
275 * @tc.desc: OnClientTransLimitChangeInnerTest, ReadCString faild return SOFTBUS_ERR
276 * @tc.desc: OnClientTransLimitChangeInnerTest, success return SOFTBUS_OK
277 * @tc.type: FUNC
278 * @tc.require:
279 */
280 HWTEST_F(SoftBusServerProxyFrameTest, OnClientTransLimitChangeInnerTest, TestSize.Level1)
281 {
282 ASSERT_TRUE(g_stub != nullptr);
283 MessageParcel data;
284 MessageParcel reply;
285 EXPECT_EQ(g_stub->OnClientTransLimitChangeInner(data, reply), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED);
286
287 data.WriteInt32(0);
288 EXPECT_EQ(g_stub->OnClientTransLimitChangeInner(data, reply), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED);
289
290 data.WriteInt32(0);
291 data.WriteUint8(0);
292 EXPECT_EQ(g_stub->OnClientTransLimitChangeInner(data, reply), SOFTBUS_OK);
293
294 int32_t ret = g_stub->OnClientTransLimitChange(0, 0);
295 EXPECT_EQ(ret, SOFTBUS_OK);
296 }
297
298 /**
299 * @tc.name: OnChannelQosEventInnerTest
300 * @tc.desc: OnChannelQosEventInnerTest, ReadInt32 faild return SOFTBUS_ERR
301 * @tc.desc: OnChannelQosEventInnerTest, ReadCString faild return SOFTBUS_ERR
302 * @tc.desc: OnChannelQosEventInnerTest, success return SOFTBUS_OK
303 * @tc.type: FUNC
304 * @tc.require:
305 */
306 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelQosEventInnerTest, TestSize.Level1)
307 {
308 ASSERT_TRUE(g_stub != nullptr);
309 MessageParcel data;
310 MessageParcel reply;
311 EXPECT_EQ(g_stub->OnChannelQosEventInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
312
313 data.WriteInt32(0);
314 EXPECT_EQ(g_stub->OnChannelQosEventInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
315
316 data.WriteInt32(0);
317 data.WriteInt32(0);
318 EXPECT_EQ(g_stub->OnChannelQosEventInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
319
320 data.WriteInt32(0);
321 data.WriteInt32(0);
322 data.WriteInt32(0);
323 EXPECT_EQ(g_stub->OnChannelQosEventInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
324
325 std::string buffer = "OnChannelQosEventInnerTest";
326 data.WriteInt32(0);
327 data.WriteInt32(0);
328 data.WriteInt32(0);
329 data.WriteInt32(1); // test value
330 data.WriteRawData(buffer.c_str(), buffer.size());
331 EXPECT_EQ(g_stub->OnChannelQosEventInner(data, reply), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED);
332
333 data.WriteInt32(0);
334 data.WriteInt32(0);
335 data.WriteInt32(0);
336 data.WriteInt32(1); // test value
337 data.WriteRawData(buffer.c_str(), buffer.size());
338 data.WriteInt32(0);
339 EXPECT_NE(g_stub->OnChannelQosEventInner(data, reply), SOFTBUS_OK);
340 }
341
342 /**
343 * @tc.name: OnChannelOnQosInnerTest
344 * @tc.desc: OnChannelOnQosInnerTest, ReadInt32 faild return SOFTBUS_ERR
345 * @tc.desc: OnChannelOnQosInnerTest, ReadCString faild return SOFTBUS_ERR
346 * @tc.desc: OnChannelOnQosInnerTest, success return SOFTBUS_OK
347 * @tc.type: FUNC
348 * @tc.require:
349 */
350 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelOnQosInnerTest, TestSize.Level1)
351 {
352 ASSERT_TRUE(g_stub != nullptr);
353 MessageParcel data;
354 MessageParcel reply;
355 EXPECT_EQ(g_stub->OnChannelOnQosInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
356
357 data.WriteInt32(0);
358 EXPECT_EQ(g_stub->OnChannelOnQosInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
359
360 data.WriteInt32(0);
361 data.WriteInt32(0);
362 EXPECT_EQ(g_stub->OnChannelOnQosInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
363
364 data.WriteInt32(0);
365 data.WriteInt32(0);
366 data.WriteInt32(0);
367 EXPECT_EQ(g_stub->OnChannelOnQosInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
368
369 data.WriteInt32(0);
370 data.WriteInt32(0);
371 data.WriteInt32(0);
372 data.WriteUint32(11); // test value
373 EXPECT_EQ(g_stub->OnChannelOnQosInner(data, reply), SOFTBUS_INVALID_PARAM);
374
375 data.WriteInt32(0);
376 data.WriteInt32(0);
377 data.WriteInt32(0);
378 data.WriteUint32(1); // test value
379 EXPECT_EQ(g_stub->OnChannelOnQosInner(data, reply), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED);
380
381 std::string buffer = "OnChannelOnQosInnerTest";
382 data.WriteInt32(0);
383 data.WriteInt32(0);
384 data.WriteInt32(0);
385 data.WriteUint32(1); // test value
386 data.WriteRawData(buffer.c_str(), buffer.size());
387 EXPECT_EQ(g_stub->OnChannelOnQosInner(data, reply), SOFTBUS_OK);
388 }
389
390 /**
391 * @tc.name: SetChannelInfoInnerTest
392 * @tc.desc: SetChannelInfoInnerTest, ReadInt32 faild return SOFTBUS_ERR
393 * @tc.desc: SetChannelInfoInnerTest, ReadCString faild return SOFTBUS_ERR
394 * @tc.desc: SetChannelInfoInnerTest, success return SOFTBUS_OK
395 * @tc.type: FUNC
396 * @tc.require:
397 */
398 HWTEST_F(SoftBusServerProxyFrameTest, SetChannelInfoInnerTest, TestSize.Level1)
399 {
400 ASSERT_TRUE(g_stub != nullptr);
401 MessageParcel data;
402 MessageParcel reply;
403 EXPECT_EQ(g_stub->SetChannelInfoInner(data, reply), SOFTBUS_IPC_ERR);
404
405 data.WriteCString("SetChannelInfoInnerTest");
406 EXPECT_EQ(g_stub->SetChannelInfoInner(data, reply), SOFTBUS_IPC_ERR);
407
408 data.WriteCString("SetChannelInfoInnerTest");
409 data.WriteInt32(0);
410 EXPECT_EQ(g_stub->SetChannelInfoInner(data, reply), SOFTBUS_IPC_ERR);
411
412 data.WriteCString("SetChannelInfoInnerTest");
413 data.WriteInt32(0);
414 data.WriteInt32(0);
415 EXPECT_EQ(g_stub->SetChannelInfoInner(data, reply), SOFTBUS_IPC_ERR);
416
417 data.WriteCString("SetChannelInfoInnerTest");
418 data.WriteInt32(0);
419 data.WriteInt32(0);
420 data.WriteInt32(0);
421 EXPECT_EQ(g_stub->SetChannelInfoInner(data, reply), SOFTBUS_OK);
422 }
423
424 /**
425 * @tc.name: OnLeaveLNNResultInnerTest
426 * @tc.desc: OnLeaveLNNResultInnerTest, ReadInt32 faild return SOFTBUS_ERR
427 * @tc.desc: OnLeaveLNNResultInnerTest, ReadCString faild return SOFTBUS_ERR
428 * @tc.desc: OnLeaveLNNResultInnerTest, success return SOFTBUS_OK
429 * @tc.type: FUNC
430 * @tc.require:
431 */
432 HWTEST_F(SoftBusServerProxyFrameTest, OnLeaveLNNResultInnerTest, TestSize.Level1)
433 {
434 ASSERT_TRUE(g_stub != nullptr);
435 MessageParcel data;
436 MessageParcel reply;
437 EXPECT_EQ(g_stub->OnLeaveLNNResultInner(data, reply), SOFTBUS_TRANS_PROXY_READCSTRING_FAILED);
438
439 data.WriteCString("OnLeaveLNNResultInnerTest");
440 EXPECT_EQ(g_stub->OnLeaveLNNResultInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
441
442 data.WriteCString("OnLeaveLNNResultInnerTest");
443 data.WriteInt32(0);
444 EXPECT_EQ(g_stub->OnLeaveLNNResultInner(data, reply), SOFTBUS_OK);
445 }
446
447 /**
448 * @tc.name: OnNodeOnlineStateChangedInnerTest
449 * @tc.desc: OnNodeOnlineStateChangedInnerTest, ReadInt32 faild return SOFTBUS_ERR
450 * @tc.desc: OnNodeOnlineStateChangedInnerTest, ReadCString faild return SOFTBUS_ERR
451 * @tc.desc: OnNodeOnlineStateChangedInnerTest, success return SOFTBUS_OK
452 * @tc.type: FUNC
453 * @tc.require:
454 */
455 HWTEST_F(SoftBusServerProxyFrameTest, OnNodeOnlineStateChangedInnerTest, TestSize.Level1)
456 {
457 ASSERT_TRUE(g_stub != nullptr);
458 MessageParcel data;
459 MessageParcel reply;
460 EXPECT_EQ(g_stub->OnNodeOnlineStateChangedInner(data, reply), SOFTBUS_TRANS_PROXY_READCSTRING_FAILED);
461
462 data.WriteCString("OnNodeOnlineStateChangedInnerTest");
463 EXPECT_EQ(g_stub->OnNodeOnlineStateChangedInner(data, reply), SOFTBUS_TRANS_PROXY_READBOOL_FAILED);
464
465 data.WriteCString("OnNodeOnlineStateChangedInnerTest");
466 data.WriteBool(false);
467 EXPECT_EQ(g_stub->OnNodeOnlineStateChangedInner(data, reply), SOFTBUS_TRANS_PROXY_READUINT_FAILED);
468
469 data.WriteCString("OnNodeOnlineStateChangedInnerTest");
470 data.WriteBool(false);
471 data.WriteUint32(sizeof(NodeBasicInfo));
472 EXPECT_EQ(g_stub->OnNodeOnlineStateChangedInner(data, reply), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED);
473
474 std::string buffer = "OnNodeOnlineStateChangedInnerTest";
475 data.WriteCString("OnNodeOnlineStateChangedInnerTest");
476 data.WriteBool(false);
477 data.WriteUint32(sizeof(NodeBasicInfo));
478 data.WriteRawData(buffer.c_str(), buffer.size());
479 EXPECT_EQ(g_stub->OnNodeOnlineStateChangedInner(data, reply), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED);
480 }
481
482 /**
483 * @tc.name: OnNodeStatusChangedInnerTest
484 * @tc.desc: OnNodeStatusChangedInnerTest, ReadInt32 faild return SOFTBUS_ERR
485 * @tc.desc: OnNodeStatusChangedInnerTest, ReadCString faild return SOFTBUS_ERR
486 * @tc.desc: OnNodeStatusChangedInnerTest, success return SOFTBUS_OK
487 * @tc.type: FUNC
488 * @tc.require:
489 */
490 HWTEST_F(SoftBusServerProxyFrameTest, OnNodeStatusChangedInnerTest, TestSize.Level1)
491 {
492 ASSERT_TRUE(g_stub != nullptr);
493 MessageParcel data;
494 MessageParcel reply;
495 EXPECT_EQ(g_stub->OnNodeStatusChangedInner(data, reply), SOFTBUS_INVALID_PARAM);
496
497 data.WriteCString("OnNodeStatusChangedInnerTest");
498 EXPECT_EQ(g_stub->OnNodeStatusChangedInner(data, reply), SOFTBUS_NETWORK_READINT32_FAILED);
499
500 data.WriteCString("OnNodeStatusChangedInnerTest");
501 data.WriteInt32(0);
502 EXPECT_EQ(g_stub->OnNodeStatusChangedInner(data, reply), SOFTBUS_NETWORK_READINT32_FAILED);
503
504 data.WriteCString("OnNodeStatusChangedInnerTest");
505 data.WriteInt32(0);
506 data.WriteUint32(sizeof(NodeStatus));
507 EXPECT_EQ(g_stub->OnNodeStatusChangedInner(data, reply), SOFTBUS_NETWORK_READRAWDATA_FAILED);
508
509 std::string buffer = "OnNodeStatusChangedInnerTest";
510 data.WriteCString("OnNodeStatusChangedInnerTest");
511 data.WriteInt32(0);
512 data.WriteUint32(sizeof(NodeStatus));
513 data.WriteRawData(buffer.c_str(), buffer.size());
514 EXPECT_EQ(g_stub->OnNodeStatusChangedInner(data, reply), SOFTBUS_NETWORK_READRAWDATA_FAILED);
515 }
516
517 /**
518 * @tc.name: OnNodeBasicInfoChangedInnerTest
519 * @tc.desc: OnNodeBasicInfoChangedInnerTest, ReadInt32 faild return SOFTBUS_ERR
520 * @tc.desc: OnNodeBasicInfoChangedInnerTest, ReadCString faild return SOFTBUS_ERR
521 * @tc.desc: OnNodeBasicInfoChangedInnerTest, success return SOFTBUS_OK
522 * @tc.type: FUNC
523 * @tc.require:
524 */
525 HWTEST_F(SoftBusServerProxyFrameTest, OnNodeBasicInfoChangedInnerTest, TestSize.Level1)
526 {
527 ASSERT_TRUE(g_stub != nullptr);
528 MessageParcel data;
529 MessageParcel reply;
530 EXPECT_EQ(g_stub->OnNodeBasicInfoChangedInner(data, reply), SOFTBUS_TRANS_PROXY_READCSTRING_FAILED);
531
532 data.WriteCString("OnNodeBasicInfoChangedInnerTest");
533 EXPECT_EQ(g_stub->OnNodeBasicInfoChangedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
534
535 data.WriteCString("OnNodeBasicInfoChangedInnerTest");
536 data.WriteInt32(0);
537 EXPECT_EQ(g_stub->OnNodeBasicInfoChangedInner(data, reply), SOFTBUS_TRANS_PROXY_READUINT_FAILED);
538
539 data.WriteCString("OnNodeBasicInfoChangedInnerTest");
540 data.WriteInt32(0);
541 data.WriteUint32(sizeof(NodeBasicInfo));
542 EXPECT_EQ(g_stub->OnNodeBasicInfoChangedInner(data, reply), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED);
543
544 std::string buffer = "OnNodeBasicInfoChangedInnerTest";
545 data.WriteCString("OnNodeBasicInfoChangedInnerTest");
546 data.WriteInt32(0);
547 data.WriteUint32(sizeof(NodeBasicInfo));
548 data.WriteRawData(buffer.c_str(), buffer.size());
549 EXPECT_EQ(g_stub->OnNodeBasicInfoChangedInner(data, reply), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED);
550 }
551
552 /**
553 * @tc.name: OnLocalNetworkIdChangedInnerTest
554 * @tc.desc: OnLocalNetworkIdChangedInnerTest, ReadInt32 faild return SOFTBUS_ERR
555 * @tc.desc: OnLocalNetworkIdChangedInnerTest, ReadCString faild return SOFTBUS_ERR
556 * @tc.desc: OnLocalNetworkIdChangedInnerTest, success return SOFTBUS_OK
557 * @tc.type: FUNC
558 * @tc.require:
559 */
560 HWTEST_F(SoftBusServerProxyFrameTest, OnLocalNetworkIdChangedInnerTest, TestSize.Level1)
561 {
562 ASSERT_TRUE(g_stub != nullptr);
563 MessageParcel data;
564 MessageParcel reply;
565 EXPECT_EQ(g_stub->OnLocalNetworkIdChangedInner(data, reply), SOFTBUS_INVALID_PARAM);
566
567 data.WriteCString("OnLocalNetworkIdChangedInnerTest");
568 EXPECT_EQ(g_stub->OnLocalNetworkIdChangedInner(data, reply), SOFTBUS_OK);
569
570 data.WriteCString("OnLocalNetworkIdChangedInnerTest");
571 data.WriteInt32(0);
572 EXPECT_EQ(g_stub->OnLocalNetworkIdChangedInner(data, reply), SOFTBUS_OK);
573 }
574
575 /**
576 * @tc.name: OnNodeDeviceTrustedChangeInnerTest
577 * @tc.desc: OnNodeDeviceTrustedChangeInnerTest, ReadInt32 faild return SOFTBUS_ERR
578 * @tc.desc: OnNodeDeviceTrustedChangeInnerTest, ReadCString faild return SOFTBUS_ERR
579 * @tc.desc: OnNodeDeviceTrustedChangeInnerTest, success return SOFTBUS_OK
580 * @tc.type: FUNC
581 * @tc.require:
582 */
583 HWTEST_F(SoftBusServerProxyFrameTest, OnNodeDeviceTrustedChangeInnerTest, TestSize.Level1)
584 {
585 ASSERT_TRUE(g_stub != nullptr);
586 MessageParcel data;
587 MessageParcel reply;
588 EXPECT_EQ(g_stub->OnNodeDeviceTrustedChangeInner(data, reply), SOFTBUS_INVALID_PARAM);
589
590 data.WriteCString("OnNodeDeviceTrustedChangeInnerTest");
591 EXPECT_EQ(g_stub->OnNodeDeviceTrustedChangeInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
592
593 data.WriteCString("OnNodeDeviceTrustedChangeInnerTest");
594 data.WriteInt32(0);
595 EXPECT_EQ(g_stub->OnNodeDeviceTrustedChangeInner(data, reply), SOFTBUS_TRANS_PROXY_READCSTRING_FAILED);
596
597 data.WriteCString("OnNodeDeviceTrustedChangeInnerTest");
598 data.WriteInt32(0);
599 data.WriteCString("OnNodeDeviceTrustedChangeInnerTest1");
600 EXPECT_EQ(g_stub->OnNodeDeviceTrustedChangeInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
601
602 data.WriteCString("OnNodeDeviceTrustedChangeInnerTest");
603 data.WriteInt32(0);
604 data.WriteCString("OnNodeDeviceTrustedChangeInnerTest1");
605 data.WriteUint32(0);
606 EXPECT_EQ(g_stub->OnNodeDeviceTrustedChangeInner(data, reply), SOFTBUS_OK);
607
608 data.WriteCString("OnNodeDeviceTrustedChangeInnerTest");
609 data.WriteInt32(0);
610 data.WriteCString("OnNodeDeviceTrustedChangeInnerTest1");
611 data.WriteUint32(0);
612 data.WriteInt32(0);
613 EXPECT_EQ(g_stub->OnNodeDeviceTrustedChangeInner(data, reply), SOFTBUS_OK);
614 }
615
616 /**
617 * @tc.name: OnHichainProofExceptionInnerTest
618 * @tc.desc: OnHichainProofExceptionInnerTest, ReadInt32 faild return SOFTBUS_ERR
619 * @tc.desc: OnHichainProofExceptionInnerTest, ReadCString faild return SOFTBUS_ERR
620 * @tc.desc: OnHichainProofExceptionInnerTest, success return SOFTBUS_OK
621 * @tc.type: FUNC
622 * @tc.require:
623 */
624 HWTEST_F(SoftBusServerProxyFrameTest, OnHichainProofExceptionInnerTest, TestSize.Level1)
625 {
626 ASSERT_TRUE(g_stub != nullptr);
627 MessageParcel data;
628 MessageParcel reply;
629 EXPECT_EQ(g_stub->OnHichainProofExceptionInner(data, reply), SOFTBUS_INVALID_PARAM);
630
631 data.WriteCString("OnHichainProofExceptionInnerTest");
632 EXPECT_EQ(g_stub->OnHichainProofExceptionInner(data, reply), SOFTBUS_NETWORK_PROXY_READINT_FAILED);
633
634 data.WriteCString("OnHichainProofExceptionInnerTest");
635 data.WriteUint32(1);
636 EXPECT_EQ(g_stub->OnHichainProofExceptionInner(data, reply), SOFTBUS_NETWORK_READRAWDATA_FAILED);
637
638 std::string buffer = "OnHichainProofExceptionInnerTest";
639 data.WriteCString("OnHichainProofExceptionInnerTest");
640 data.WriteUint32(1);
641 data.WriteRawData(buffer.c_str(), 1);
642 EXPECT_EQ(g_stub->OnHichainProofExceptionInner(data, reply), SOFTBUS_NETWORK_PROXY_READINT_FAILED);
643
644 buffer = "OnHichainProofExceptionInnerTest";
645 data.WriteCString("OnHichainProofExceptionInnerTest");
646 data.WriteUint32(1);
647 data.WriteRawData(buffer.c_str(), 1);
648 data.WriteUint16(0);
649 EXPECT_EQ(g_stub->OnHichainProofExceptionInner(data, reply), SOFTBUS_NETWORK_PROXY_READINT_FAILED);
650
651 buffer = "OnHichainProofExceptionInnerTest";
652 data.WriteCString("OnHichainProofExceptionInnerTest");
653 data.WriteUint32(1);
654 data.WriteRawData(buffer.c_str(), 1);
655 data.WriteUint16(0);
656 data.WriteInt32(0);
657 EXPECT_EQ(g_stub->OnHichainProofExceptionInner(data, reply), SOFTBUS_OK);
658 }
659
660 /**
661 * @tc.name: OnTimeSyncResultInnerTest
662 * @tc.desc: OnTimeSyncResultInnerTest, ReadInt32 faild return SOFTBUS_ERR
663 * @tc.desc: OnTimeSyncResultInnerTest, ReadCString faild return SOFTBUS_ERR
664 * @tc.desc: OnTimeSyncResultInnerTest, success return SOFTBUS_OK
665 * @tc.type: FUNC
666 * @tc.require:
667 */
668 HWTEST_F(SoftBusServerProxyFrameTest, OnTimeSyncResultInnerTest, TestSize.Level1)
669 {
670 ASSERT_TRUE(g_stub != nullptr);
671 MessageParcel data;
672 MessageParcel reply;
673 EXPECT_EQ(g_stub->OnTimeSyncResultInner(data, reply), SOFTBUS_TRANS_PROXY_READUINT_FAILED);
674
675 data.WriteInt32(sizeof(TimeSyncResultInfo));
676 EXPECT_EQ(g_stub->OnTimeSyncResultInner(data, reply), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED);
677
678 std::string buffer = "OnTimeSyncResultInnerTest";
679 data.WriteInt32(sizeof(TimeSyncResultInfo));
680 data.WriteRawData(buffer.c_str(), sizeof(TimeSyncResultInfo));
681 EXPECT_EQ(g_stub->OnTimeSyncResultInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
682
683 buffer = "OnTimeSyncResultInnerTest";
684 data.WriteInt32(sizeof(TimeSyncResultInfo));
685 data.WriteRawData(buffer.c_str(), sizeof(TimeSyncResultInfo));
686 data.WriteInt32(0);
687 EXPECT_EQ(g_stub->OnTimeSyncResultInner(data, reply), SOFTBUS_OK);
688 }
689
690 /**
691 * @tc.name: OnPublishLNNResultInnerTest
692 * @tc.desc: OnPublishLNNResultInnerTest, ReadInt32 faild return SOFTBUS_ERR
693 * @tc.desc: OnPublishLNNResultInnerTest, ReadCString faild return SOFTBUS_ERR
694 * @tc.desc: OnPublishLNNResultInnerTest, success return SOFTBUS_OK
695 * @tc.type: FUNC
696 * @tc.require:
697 */
698 HWTEST_F(SoftBusServerProxyFrameTest, OnPublishLNNResultInnerTest, TestSize.Level1)
699 {
700 ASSERT_TRUE(g_stub != nullptr);
701 MessageParcel data;
702 MessageParcel reply;
703 EXPECT_EQ(g_stub->OnPublishLNNResultInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
704
705 data.WriteInt32(0);
706 EXPECT_EQ(g_stub->OnPublishLNNResultInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
707
708 std::string buffer = "OnPublishLNNResultInnerTest";
709 data.WriteInt32(0);
710 data.WriteRawData(buffer.c_str(), buffer.size());
711 EXPECT_EQ(g_stub->OnPublishLNNResultInner(data, reply), SOFTBUS_OK);
712 }
713
714 /**
715 * @tc.name: OnRefreshLNNResultInnerTest
716 * @tc.desc: OnRefreshLNNResultInnerTest, ReadInt32 faild return SOFTBUS_ERR
717 * @tc.desc: OnRefreshLNNResultInnerTest, ReadCString faild return SOFTBUS_ERR
718 * @tc.desc: OnRefreshLNNResultInnerTest, success return SOFTBUS_OK
719 * @tc.type: FUNC
720 * @tc.require:
721 */
722 HWTEST_F(SoftBusServerProxyFrameTest, OnRefreshLNNResultInnerTest, TestSize.Level1)
723 {
724 ASSERT_TRUE(g_stub != nullptr);
725 MessageParcel data;
726 MessageParcel reply;
727 EXPECT_EQ(g_stub->OnRefreshLNNResultInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
728
729 data.WriteInt32(sizeof(DeviceInfo));
730 EXPECT_EQ(g_stub->OnRefreshLNNResultInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
731
732 data.WriteInt32(0);
733 data.WriteInt32(0);
734 EXPECT_EQ(g_stub->OnRefreshLNNResultInner(data, reply), SOFTBUS_OK);
735 }
736
737 /**
738 * @tc.name: OnRefreshDeviceFoundInnerTest
739 * @tc.desc: OnRefreshDeviceFoundInnerTest, ReadInt32 faild return SOFTBUS_ERR
740 * @tc.desc: OnRefreshDeviceFoundInnerTest, ReadCString faild return SOFTBUS_ERR
741 * @tc.desc: OnRefreshDeviceFoundInnerTest, success return SOFTBUS_OK
742 * @tc.type: FUNC
743 * @tc.require:
744 */
745 HWTEST_F(SoftBusServerProxyFrameTest, OnRefreshDeviceFoundInnerTest, TestSize.Level1)
746 {
747 ASSERT_TRUE(g_stub != nullptr);
748 MessageParcel data;
749 MessageParcel reply;
750 EXPECT_EQ(g_stub->OnRefreshDeviceFoundInner(data, reply), SOFTBUS_TRANS_PROXY_READUINT_FAILED);
751
752 data.WriteInt32(sizeof(DeviceInfo));
753 EXPECT_EQ(g_stub->OnRefreshDeviceFoundInner(data, reply), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED);
754 }
755
756 /**
757 * @tc.name: OnDataLevelChangedInnerTest
758 * @tc.desc: OnDataLevelChangedInnerTest, ReadInt32 faild return SOFTBUS_ERR
759 * @tc.desc: OnDataLevelChangedInnerTest, ReadCString faild return SOFTBUS_ERR
760 * @tc.desc: OnDataLevelChangedInnerTest, success return SOFTBUS_OK
761 * @tc.type: FUNC
762 * @tc.require:
763 */
764 HWTEST_F(SoftBusServerProxyFrameTest, OnDataLevelChangedInnerTest, TestSize.Level1)
765 {
766 ASSERT_TRUE(g_stub != nullptr);
767 MessageParcel data;
768 MessageParcel reply;
769 EXPECT_EQ(g_stub->OnDataLevelChangedInner(data, reply), SOFTBUS_TRANS_PROXY_READCSTRING_FAILED);
770
771 data.WriteCString("OnDataLevelChangedInnerTest");
772 EXPECT_EQ(g_stub->OnDataLevelChangedInner(data, reply), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED);
773
774 std::string buffer = "OnDataLevelChangedInnerTest";
775 data.WriteCString("OnDataLevelChangedInnerTest");
776 data.WriteRawData(buffer.c_str(), sizeof(DataLevelInfo));
777 EXPECT_EQ(g_stub->OnDataLevelChangedInner(data, reply), SOFTBUS_OK);
778 }
779
780 /**
781 * @tc.name: OnRangeResultInnerTest
782 * @tc.desc: OnRangeResultInnerTest, ReadInt32 faild return SOFTBUS_ERR
783 * @tc.desc: OnRangeResultInnerTest, ReadCString faild return SOFTBUS_ERR
784 * @tc.desc: OnRangeResultInnerTest, success return SOFTBUS_OK
785 * @tc.type: FUNC
786 * @tc.require:
787 */
788 HWTEST_F(SoftBusServerProxyFrameTest, OnRangeResultInnerTest, TestSize.Level1)
789 {
790 ASSERT_TRUE(g_stub != nullptr);
791 MessageParcel data;
792 MessageParcel reply;
793 EXPECT_EQ(g_stub->OnMsdpRangeResultInner(data, reply), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED);
794
795 RangeResultInnerInfo innerIInnfo1 = { .length = 0, };
796 data.WriteRawData(&innerIInnfo1, sizeof(RangeResultInnerInfo));
797 EXPECT_EQ(g_stub->OnMsdpRangeResultInner(data, reply), SOFTBUS_OK);
798
799 RangeResultInnerInfo temp;
800 RangeResultInnerInfo innerIInnfo2 = { .length = sizeof(temp), .addition = (uint8_t *)&temp };
801 data.WriteRawData(&innerIInnfo2, sizeof(RangeResultInnerInfo));
802 data.WriteRawData(&temp, sizeof(temp));
803 EXPECT_EQ(g_stub->OnMsdpRangeResultInner(data, reply), SOFTBUS_OK);
804 }
805
806 /**
807 * @tc.name: OnChannelBindInnerTest
808 * @tc.desc: OnChannelBindInnerTest, ReadInt32 faild return SOFTBUS_ERR
809 * @tc.desc: OnChannelBindInnerTest, ReadCString faild return SOFTBUS_ERR
810 * @tc.desc: OnChannelBindInnerTest, success return SOFTBUS_OK
811 * @tc.type: FUNC
812 * @tc.require:
813 */
814 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelBindInnerTest, TestSize.Level1)
815 {
816 ASSERT_TRUE(g_stub != nullptr);
817 MessageParcel data;
818 MessageParcel reply;
819 EXPECT_EQ(g_stub->OnChannelBindInner(data, reply), SOFTBUS_IPC_ERR);
820
821 data.WriteInt32(0);
822 EXPECT_EQ(g_stub->OnChannelBindInner(data, reply), SOFTBUS_IPC_ERR);
823
824 data.WriteInt32(0);
825 data.WriteInt32(0);
826 EXPECT_EQ(g_stub->OnChannelBindInner(data, reply), SOFTBUS_OK);
827 }
828
829 /**
830 * @tc.name: OnCheckCollabRelationTest
831 * @tc.desc: OnCheckCollabRelationTest, ReadInt32 faild return SOFTBUS_ERR
832 * @tc.desc: OnCheckCollabRelationTest, ReadCString faild return SOFTBUS_ERR
833 * @tc.desc: OnCheckCollabRelationTest, success return SOFTBUS_OK
834 * @tc.type: FUNC
835 * @tc.require:
836 */
837 HWTEST_F(SoftBusServerProxyFrameTest, OnCheckCollabRelationTest, TestSize.Level1)
838 {
839 ASSERT_TRUE(g_stub != nullptr);
840 int32_t ret = g_stub->OnCheckCollabRelation(nullptr, true, nullptr, 0, 0);
841 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
842
843 CollabInfo *sourceInfo = static_cast<CollabInfo *>(SoftBusCalloc(sizeof(CollabInfo)));
844 EXPECT_NE(nullptr, sourceInfo);
845
846 CollabInfo *sinkInfo = static_cast<CollabInfo *>(SoftBusCalloc(sizeof(CollabInfo)));
847 EXPECT_NE(nullptr, sinkInfo);
848
849 ret = g_stub->OnCheckCollabRelation(sourceInfo, true, sinkInfo, 0, 0);
850 EXPECT_EQ(ret, SOFTBUS_OK);
851 SoftBusFree(sourceInfo);
852 SoftBusFree(sinkInfo);
853 }
854
855 /**
856 * @tc.name: OnClientChannelOnQosTest
857 * @tc.desc: OnClientChannelOnQosTest, ReadInt32 faild return SOFTBUS_ERR
858 * @tc.desc: OnClientChannelOnQosTest, ReadCString faild return SOFTBUS_ERR
859 * @tc.desc: OnClientChannelOnQosTest, success return SOFTBUS_OK
860 * @tc.type: FUNC
861 * @tc.require:
862 */
863 HWTEST_F(SoftBusServerProxyFrameTest, OnClientChannelOnQosTest, TestSize.Level1)
864 {
865 ASSERT_TRUE(g_stub != nullptr);
866 int32_t ret = g_stub->OnClientChannelOnQos(0, 0, static_cast<QoSEvent>(-1), nullptr, 0);
867 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
868
869 ret = g_stub->OnClientChannelOnQos(0, 0, static_cast<QoSEvent>(5), nullptr, 0); // test value
870 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
871
872 ret = g_stub->OnClientChannelOnQos(0, 0, QOS_SATISFIED, nullptr, 0);
873 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
874
875 QosTV *qos = static_cast<QosTV *>(SoftBusCalloc(sizeof(QosTV)));
876 EXPECT_NE(nullptr, qos);
877
878 ret = g_stub->OnClientChannelOnQos(0, 0, QOS_SATISFIED, qos, 0);
879 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
880
881 ret = g_stub->OnClientChannelOnQos(0, 0, QOS_SATISFIED, qos, 1);
882 EXPECT_NE(ret, SOFTBUS_OK);
883 SoftBusFree(qos);
884 }
885
886 /**
887 * @tc.name: OnChannelOpenedInnerTest001
888 * @tc.desc: OnChannelOpenedInnerTest001, MessageParcel read failed return SOFTBUS_ERR
889 * @tc.type: FUNC
890 * @tc.require:
891 */
892 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelOpenedInnerTest001, TestSize.Level1)
893 {
894 ASSERT_TRUE(g_stub != nullptr);
895 MessageParcel data;
896 MessageParcel reply;
897 MessageParcel tempData;
898 EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
899
900 data.WriteCString("OnChannelOpenedInnerTest");
901 EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
902
903 data.WriteCString("OnChannelOpenedInnerTest");
904 data.WriteInt32(0);
905 EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
906
907 data.WriteCString("OnChannelOpenedInnerTest");
908 data.WriteInt32(0);
909 data.WriteInt32(0);
910 EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
911
912 data.WriteCString("OnChannelOpenedInnerTest");
913 data.WriteInt32(0);
914 data.WriteInt32(0);
915 data.WriteBool(false);
916 EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
917
918 data.WriteCString("OnChannelOpenedInnerTest");
919 data.WriteInt32(0);
920 data.WriteInt32(0);
921 data.WriteBool(false);
922 data.WriteBool(true);
923 EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
924
925 data.WriteCString("OnChannelOpenedInnerTest");
926 data.WriteInt32(0);
927 data.WriteInt32(0);
928 data.WriteBool(false);
929 data.WriteBool(true);
930 data.WriteBool(false);
931 EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
932 }
933
934 /**
935 * @tc.name: OnChannelOpenedInnerTest002
936 * @tc.desc: OnChannelOpenedInnerTest002, MessageParcel read failed return SOFTBUS_ERR
937 * @tc.type: FUNC
938 * @tc.require:
939 */
940 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelOpenedInnerTest002, TestSize.Level1)
941 {
942 ASSERT_TRUE(g_stub != nullptr);
943 MessageParcel data;
944 MessageParcel reply;
945
946 data.WriteCString("OnChannelOpenedInnerTest");
947 data.WriteInt32(0);
948 data.WriteInt32(0);
949 data.WriteBool(false);
950 data.WriteBool(true);
951 data.WriteBool(false);
952 data.WriteInt32(0);
953 EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
954
955 data.WriteCString("OnChannelOpenedInnerTest");
956 data.WriteInt32(0);
957 data.WriteInt32(0);
958 data.WriteBool(false);
959 data.WriteBool(true);
960 data.WriteBool(false);
961 data.WriteInt32(0);
962 data.WriteInt32(0);
963 EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
964
965 data.WriteCString("OnChannelOpenedInnerTest");
966 data.WriteInt32(0);
967 data.WriteInt32(0);
968 data.WriteBool(false);
969 data.WriteBool(true);
970 data.WriteBool(false);
971 data.WriteInt32(0);
972 data.WriteInt32(0);
973 data.WriteCString("OnChannelOpenedInnerTest");
974 EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
975 }
976
977 /**
978 * @tc.name: OnChannelOpenFailedInnerTest
979 * @tc.desc: OnChannelOpenFailedInnerTest, ReadInt32 failed return SOFTBUS_ERR
980 * @tc.desc: OnChannelOpenFailedInnerTest, success return SOFTBUS_OK
981 * @tc.type: FUNC
982 * @tc.require:
983 */
984 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelOpenFailedInnerTest, TestSize.Level1)
985 {
986 ASSERT_TRUE(g_stub != nullptr);
987 MessageParcel data;
988 MessageParcel reply;
989 EXPECT_EQ(g_stub->OnChannelOpenFailedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
990
991 data.WriteInt32(0);
992 EXPECT_EQ(g_stub->OnChannelOpenFailedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
993
994 data.WriteInt32(0);
995 data.WriteInt32(99);
996 EXPECT_EQ(g_stub->OnChannelOpenFailedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
997
998 data.WriteInt32(0);
999 data.WriteInt32(0);
1000 data.WriteInt32(0);
1001 EXPECT_EQ(g_stub->OnChannelOpenFailedInner(data, reply), SOFTBUS_OK);
1002 }
1003
1004 /**
1005 * @tc.name: OnChannelLinkDownInnerTest
1006 * @tc.desc: OnChannelLinkDownInnerTest, ReadCString failed return SOFTBUS_ERR
1007 * @tc.desc: OnChannelLinkDownInnerTest, ReadInt32 failed return SOFTBUS_ERR
1008 * @tc.desc: OnChannelLinkDownInnerTest, success return SOFTBUS_OK
1009 * @tc.type: FUNC
1010 * @tc.require:
1011 */
1012 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelLinkDownInnerTest, TestSize.Level1)
1013 {
1014 ASSERT_TRUE(g_stub != nullptr);
1015 MessageParcel data;
1016 MessageParcel reply;
1017 EXPECT_EQ(g_stub->OnChannelLinkDownInner(data, reply), SOFTBUS_TRANS_PROXY_READCSTRING_FAILED);
1018
1019 data.WriteCString("OnChannelLinkDownInnerTest");
1020 EXPECT_EQ(g_stub->OnChannelLinkDownInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
1021
1022 data.WriteCString("OnChannelLinkDownInnerTest");
1023 data.WriteInt32(0);
1024 EXPECT_EQ(g_stub->OnChannelLinkDownInner(data, reply), SOFTBUS_OK);
1025 }
1026
1027 /**
1028 * @tc.name: OnChannelClosedInnerTest
1029 * @tc.desc: OnChannelClosedInnerTest, ReadInt32 failed return SOFTBUS_ERR
1030 * @tc.desc: OnChannelClosedInnerTest, success return SOFTBUS_OK
1031 * @tc.type: FUNC
1032 * @tc.require:
1033 */
1034 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelClosedInnerTest, TestSize.Level1)
1035 {
1036 ASSERT_TRUE(g_stub != nullptr);
1037 MessageParcel data;
1038 MessageParcel reply;
1039 EXPECT_EQ(g_stub->OnChannelClosedInner(data, reply), SOFTBUS_IPC_ERR);
1040
1041 data.WriteInt32(0);
1042 EXPECT_EQ(g_stub->OnChannelClosedInner(data, reply), SOFTBUS_IPC_ERR);
1043
1044 data.WriteInt32(0);
1045 data.WriteInt32(0);
1046 EXPECT_EQ(g_stub->OnChannelClosedInner(data, reply), SOFTBUS_IPC_ERR);
1047 }
1048
1049 /**
1050 * @tc.name: OnChannelMsgReceivedInnerTest
1051 * @tc.desc: OnChannelMsgReceivedInnerTest, MessageParcel failed return SOFTBUS_ERR
1052 * @tc.desc: OnChannelMsgReceivedInnerTest, success return SOFTBUS_OK
1053 * @tc.type: FUNC
1054 * @tc.require:
1055 */
1056 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelMsgReceivedInnerTest, TestSize.Level1)
1057 {
1058 ASSERT_TRUE(g_stub != nullptr);
1059 MessageParcel data;
1060 MessageParcel reply;
1061 EXPECT_EQ(g_stub->OnChannelMsgReceivedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
1062
1063 data.WriteInt32(0);
1064 EXPECT_EQ(g_stub->OnChannelMsgReceivedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
1065
1066 data.WriteInt32(0);
1067 data.WriteInt32(0);
1068 EXPECT_EQ(g_stub->OnChannelMsgReceivedInner(data, reply), SOFTBUS_TRANS_PROXY_READUINT_FAILED);
1069
1070 data.WriteInt32(0);
1071 data.WriteInt32(0);
1072 data.WriteUint32(0);
1073 EXPECT_EQ(g_stub->OnChannelMsgReceivedInner(data, reply), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED);
1074
1075 std::string buffer = "OnChannelMsgReceivedInnerTest";
1076 data.WriteInt32(0);
1077 data.WriteInt32(0);
1078 data.WriteUint32(buffer.size());
1079 data.WriteRawData(buffer.c_str(), buffer.size());
1080 EXPECT_EQ(g_stub->OnChannelMsgReceivedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
1081
1082 data.WriteInt32(0);
1083 data.WriteInt32(0);
1084 data.WriteUint32(buffer.size());
1085 data.WriteRawData(buffer.c_str(), buffer.size());
1086 data.WriteInt32(0);
1087 EXPECT_EQ(g_stub->OnChannelMsgReceivedInner(data, reply), SOFTBUS_OK);
1088 }
1089
1090 /**
1091 * @tc.name: ISoftBusClientTest001
1092 * @tc.desc: ISoftBusClientTest, use normal or wrong param
1093 * @tc.type: FUNC
1094 * @tc.require:
1095 */
1096 HWTEST_F(SoftBusServerProxyFrameTest, ISoftBusClientTest001, TestSize.Level1)
1097 {
1098 ASSERT_TRUE(g_stub != nullptr);
1099 int32_t testInt = 0;
1100 uint32_t testUint = 0;
1101 g_stub->OnPublishLNNResult(testInt, testInt);
1102 g_stub->OnRefreshLNNResult(testInt, testInt);
1103 g_stub->OnRefreshDeviceFound(nullptr, testUint);
1104 g_stub->OnDataLevelChanged(nullptr, nullptr);
1105 int32_t ret = g_stub->OnChannelOpened(nullptr, nullptr);
1106 EXPECT_EQ(ret, SOFTBUS_OK);
1107 ret = g_stub->OnChannelOpenFailed(testInt, testInt, testInt);
1108 EXPECT_EQ(ret, SOFTBUS_OK);
1109 ret = g_stub->OnChannelLinkDown(nullptr, testInt);
1110 EXPECT_EQ(ret, SOFTBUS_OK);
1111 ret = g_stub->OnChannelMsgReceived(testInt, testInt, nullptr, testUint, testInt);
1112 EXPECT_EQ(ret, SOFTBUS_OK);
1113 ret = g_stub->OnChannelClosed(testInt, testInt, testInt);
1114 EXPECT_EQ(ret, SOFTBUS_OK);
1115 ret = g_stub->OnChannelQosEvent(testInt, testInt, testInt, testInt, nullptr);
1116 EXPECT_EQ(ret, SOFTBUS_OK);
1117 ret = g_stub->SetChannelInfo(nullptr, testInt, testInt, testInt);
1118 EXPECT_EQ(ret, SOFTBUS_OK);
1119 ret = g_stub->OnJoinLNNResult(nullptr, testUint, nullptr, testInt);
1120 EXPECT_EQ(ret, SOFTBUS_OK);
1121 ret = g_stub->OnNodeOnlineStateChanged(nullptr, true, nullptr, testUint);
1122 EXPECT_EQ(ret, SOFTBUS_OK);
1123 ret = g_stub->OnNodeBasicInfoChanged(nullptr, nullptr, testUint, testInt);
1124 EXPECT_EQ(ret, SOFTBUS_OK);
1125 ret = g_stub->OnLocalNetworkIdChanged(nullptr);
1126 EXPECT_EQ(ret, SOFTBUS_OK);
1127 ret = g_stub->OnTimeSyncResult(nullptr, testUint, testInt);
1128 EXPECT_EQ(ret, SOFTBUS_OK);
1129 ret = g_stub->OnClientTransLimitChange(testInt, testUint);
1130 EXPECT_EQ(ret, SOFTBUS_OK);
1131 ret = g_stub->OnChannelBind(testInt, testInt);
1132 EXPECT_EQ(ret, SOFTBUS_OK);
1133 }
1134
1135 /**
1136 * @tc.name: OnRemoteDiedTest
1137 * @tc.desc: OnRemoteDiedTest, use normal or wrong param
1138 * @tc.type: FUNC
1139 * @tc.require:
1140 */
1141 HWTEST_F(SoftBusServerProxyFrameTest, OnRemoteDiedTest, TestSize.Level1)
1142 {
1143 ASSERT_TRUE(g_mock != nullptr);
1144 g_mock->OnRemoteDied(nullptr);
1145 }
1146
1147 /**
1148 * @tc.name: OnConnectionStateChangeInner
1149 * @tc.desc: OnConnectionStateChangeInner, MessageParcel failed return SOFTBUS_IPC_ERR
1150 * @tc.desc: OnConnectionStateChangeInner, success return SOFTBUS_OK
1151 * @tc.type: FUNC
1152 * @tc.require:
1153 */
1154 HWTEST_F(SoftBusServerProxyFrameTest, OnConnectionStateChangeInnerTest, TestSize.Level1)
1155 {
1156 ASSERT_TRUE(g_stub != nullptr);
1157 MessageParcel data;
1158 MessageParcel reply;
1159 EXPECT_EQ(g_stub->OnConnectionStateChangeInner(data, reply), SOFTBUS_IPC_ERR);
1160
1161 data.WriteInt32(0);
1162 EXPECT_EQ(g_stub->OnConnectionStateChangeInner(data, reply), SOFTBUS_IPC_ERR);
1163
1164 data.WriteInt32(0);
1165 data.WriteInt32(0);
1166 EXPECT_EQ(g_stub->OnConnectionStateChangeInner(data, reply), SOFTBUS_IPC_ERR);
1167
1168 data.WriteInt32(0);
1169 data.WriteInt32(0);
1170 data.WriteUint32(0);
1171 EXPECT_EQ(g_stub->OnConnectionStateChangeInner(data, reply), SOFTBUS_OK);
1172 }
1173
1174 /**
1175 * @tc.name: OnAcceptConnectInner
1176 * @tc.desc: OnAcceptConnectInner, MessageParcel failed return SOFTBUS_IPC_ERR
1177 * @tc.desc: OnAcceptConnectInner, success return SOFTBUS_OK
1178 * @tc.type: FUNC
1179 * @tc.require:
1180 */
1181 HWTEST_F(SoftBusServerProxyFrameTest, OnAcceptConnectInnerTest, TestSize.Level1)
1182 {
1183 ASSERT_TRUE(g_stub != nullptr);
1184 MessageParcel data;
1185 MessageParcel reply;
1186 EXPECT_EQ(g_stub->OnAcceptConnectInner(data, reply), SOFTBUS_IPC_ERR);
1187
1188 data.WriteCString("OnAcceptConnectInnerTest");
1189 EXPECT_EQ(g_stub->OnAcceptConnectInner(data, reply), SOFTBUS_IPC_ERR);
1190
1191 data.WriteCString("OnAcceptConnectInnerTest");
1192 data.WriteInt32(0);
1193 EXPECT_EQ(g_stub->OnAcceptConnectInner(data, reply), SOFTBUS_OK);
1194 }
1195
1196 /**
1197 * @tc.name: OnDataReceivedInner
1198 * @tc.desc: OnDataReceivedInner, MessageParcel failed return SOFTBUS_IPC_ERR
1199 * @tc.desc: OnDataReceivedInner, success return SOFTBUS_OK
1200 * @tc.type: FUNC
1201 * @tc.require:
1202 */
1203 HWTEST_F(SoftBusServerProxyFrameTest, OnDataReceivedInnerTest, TestSize.Level1)
1204 {
1205 ASSERT_TRUE(g_stub != nullptr);
1206 MessageParcel data;
1207 MessageParcel reply;
1208 EXPECT_EQ(g_stub->OnDataReceivedInner(data, reply), SOFTBUS_IPC_ERR);
1209
1210 data.WriteInt32(0);
1211 EXPECT_EQ(g_stub->OnAcceptConnectInner(data, reply), SOFTBUS_IPC_ERR);
1212
1213 data.WriteInt32(0);
1214 std::string buffer = "OnDataReceivedInnerTest";
1215 data.WriteUint32(buffer.size());
1216 data.WriteRawData(buffer.c_str(), buffer.size());
1217 EXPECT_EQ(g_stub->OnDataReceivedInner(data, reply), SOFTBUS_OK);
1218 }
1219 } // namespace OHOS
1220