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:
42     void OnRemoteDied(const wptr<IRemoteObject> &remote) override { }
43 };
44 
45 class SoftBusClientStubMock : public SoftBusClientStub {
46 public:
47     void OnPublishLNNResult(int32_t publishId, int32_t reason) override { }
48     void OnRefreshLNNResult(int32_t refreshId, int32_t reason) override { }
49     void OnRefreshDeviceFound(const void *device, uint32_t deviceLen) override { }
50     void OnDataLevelChanged(const char *networkId, const DataLevelInfo *dataLevelInfo) override { }
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     }
56     int32_t OnChannelOpened(const char *sessionName, const ChannelInfo *info) override
57     {
58         return SOFTBUS_OK;
59     }
60     int32_t OnJoinLNNResult(void *addr, uint32_t addrTypeLen, const char *networkId, int retCode) override
61     {
62         return SOFTBUS_OK;
63     }
64     int32_t OnNodeOnlineStateChanged(const char *pkgName, bool isOnline, void *info, uint32_t infoTypeLen) override
65     {
66         return SOFTBUS_OK;
67     }
68     int32_t OnNodeBasicInfoChanged(const char *pkgName, void *info, uint32_t infoTypeLen, int32_t type) override
69     {
70         return SOFTBUS_OK;
71     }
72     int32_t OnLocalNetworkIdChanged(const char *pkgName) override
73     {
74         return SOFTBUS_OK;
75     }
76     int32_t OnTimeSyncResult(const void *info, uint32_t infoTypeLen, int32_t retCode) override
77     {
78         return SOFTBUS_OK;
79     }
80     int32_t OnClientTransLimitChange(int32_t channelId, uint8_t tos) override
81     {
82         return SOFTBUS_OK;
83     }
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     }
89     int32_t OnChannelBind([[maybe_unused]] int32_t channelId, [[maybe_unused]] int32_t channelType) override
90     {
91         return SOFTBUS_OK;
92     }
93     int32_t OnChannelLinkDown([[maybe_unused]] const char *networkId, [[maybe_unused]] int32_t routeType) override
94     {
95         return SOFTBUS_OK;
96     }
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     }
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     }
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     }
112 };
113 
114 namespace {
115 sptr<SoftBusClientStubMock> g_stub = nullptr;
116 sptr<SoftBusClientDeathRecipientMock> g_mock = nullptr;
117 }
118 
SetUpTestCase()119 void SoftBusServerProxyFrameTest::SetUpTestCase()
120 {
121     g_stub = new (std::nothrow) SoftBusClientStubMock();
122     g_mock = new (std::nothrow) SoftBusClientDeathRecipientMock();
123 }
124 
TearDownTestCase()125 void SoftBusServerProxyFrameTest::TearDownTestCase()
126 {
127     g_stub = nullptr;
128     g_mock = nullptr;
129 }
130 
131 /**
132  * @tc.name: InnerRegisterServiceTest
133  * @tc.desc: InnerRegisterServiceTest, Initialization failure
134  * @tc.desc: InnerRegisterServiceTest, Successful initialization
135  * @tc.type: FUNC
136  * @tc.require:
137  */
HWTEST_F(SoftBusServerProxyFrameTest, InnerRegisterServiceTest, TestSize.Level1)138 HWTEST_F(SoftBusServerProxyFrameTest, InnerRegisterServiceTest, TestSize.Level1)
139 {
140     EXPECT_EQ(InnerRegisterService(NULL), SOFTBUS_INVALID_PARAM);
141 
142     EXPECT_EQ(ServerProxyInit(), SOFTBUS_OK);
143     EXPECT_EQ(InitSoftBus("SoftBusServerProxyFrameTest"), SOFTBUS_NO_INIT);
144     EXPECT_EQ(InnerRegisterService(NULL), SOFTBUS_TRANS_GET_CLIENT_NAME_FAILED);
145 
146     ListNode sessionServerList;
147     ListInit(&sessionServerList);
148     EXPECT_EQ(InnerRegisterService(&sessionServerList), SOFTBUS_TRANS_GET_CLIENT_NAME_FAILED);
149 }
150 
151 /**
152  * @tc.name: GetSystemAbilityTest
153  * @tc.desc: GetSystemAbilityTest, Get interface return is not empty
154  * @tc.type: FUNC
155  * @tc.require:
156  */
HWTEST_F(SoftBusServerProxyFrameTest, GetSystemAbilityTest, TestSize.Level1)157 HWTEST_F(SoftBusServerProxyFrameTest, GetSystemAbilityTest, TestSize.Level1)
158 {
159     EXPECT_TRUE(GetSystemAbility() != nullptr);
160 }
161 
162 /**
163  * @tc.name: ClientRegisterServiceTest
164  * @tc.desc: ClientRegisterServiceTest, Initializing registration succeeded. Procedure
165  * @tc.type: FUNC
166  * @tc.require:
167  */
HWTEST_F(SoftBusServerProxyFrameTest, ClientRegisterServiceTest, TestSize.Level1)168 HWTEST_F(SoftBusServerProxyFrameTest, ClientRegisterServiceTest, TestSize.Level1)
169 {
170     EXPECT_EQ(ServerProxyInit(), SOFTBUS_OK);
171     EXPECT_EQ(ClientRegisterService("ClientRegisterServiceTest"), SOFTBUS_SERVER_NOT_INIT);
172 }
173 
174 /**
175  * @tc.name: ClientStubInitTest
176  * @tc.desc: ClientStubInitTest, Successful initialization
177  * @tc.type: FUNC
178  * @tc.require:
179  */
HWTEST_F(SoftBusServerProxyFrameTest, ClientStubInitTest, TestSize.Level1)180 HWTEST_F(SoftBusServerProxyFrameTest, ClientStubInitTest, TestSize.Level1)
181 {
182     EXPECT_EQ(ClientStubInit(), SOFTBUS_OK);
183 }
184 
185 /**
186  * @tc.name: SoftbusRegisterServiceTest
187  * @tc.desc: SoftbusRegisterServiceTest, remote is nullptr return SOFTBUS_ERR
188  * @tc.desc: SoftbusRegisterServiceTest, SoftbusRegisterService success return SOFTBUS_OK
189  * @tc.desc: SoftbusRegisterServiceTest, clientPkgName is nullptr return SOFTBUS_ERR
190  * @tc.type: FUNC
191  * @tc.require:
192  */
HWTEST_F(SoftBusServerProxyFrameTest, SoftbusRegisterServiceTest, TestSize.Level1)193 HWTEST_F(SoftBusServerProxyFrameTest, SoftbusRegisterServiceTest, TestSize.Level1)
194 {
195     sptr<SoftBusServerProxyFrame> serverProxyFrame = new (std::nothrow) SoftBusServerProxyFrame(nullptr);
196     ASSERT_TRUE(serverProxyFrame != nullptr);
197     EXPECT_EQ(serverProxyFrame->SoftbusRegisterService("SoftbusRegisterServiceTest", nullptr), SOFTBUS_IPC_ERR);
198 
199     sptr<IRemoteObject> serverProxy = GetSystemAbility();
200     ASSERT_TRUE(serverProxy != nullptr);
201     serverProxyFrame = new (std::nothrow) SoftBusServerProxyFrame(serverProxy);
202     ASSERT_TRUE(serverProxyFrame != nullptr);
203     EXPECT_EQ(serverProxyFrame->SoftbusRegisterService("SoftbusRegisterServiceTest", nullptr), SOFTBUS_IPC_ERR);
204 
205     EXPECT_EQ(serverProxyFrame->SoftbusRegisterService(nullptr, nullptr), SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED);
206 }
207 
208 /**
209  * @tc.name: OnRemoteRequestTest
210  * @tc.desc: OnRemoteRequestTest, ReadInterfaceToken faild return SOFTBUS_ERR
211  * @tc.desc: OnRemoteRequestTest, OnRemoteRequest Call default return IPC_STUB_UNKNOW_TRANS_ERR
212  * @tc.desc: OnRemoteRequestTest, OnRemoteRequest Call CLIENT_ON_PERMISSION_CHANGE
213  * @tc.type: FUNC
214  * @tc.require:
215  */
HWTEST_F(SoftBusServerProxyFrameTest, OnRemoteRequestTest, TestSize.Level1)216 HWTEST_F(SoftBusServerProxyFrameTest, OnRemoteRequestTest, TestSize.Level1)
217 {
218     ASSERT_TRUE(g_stub != nullptr);
219     uint32_t code = 0;
220     MessageParcel data;
221     MessageParcel reply;
222     MessageOption option;
223     EXPECT_EQ(g_stub->OnRemoteRequest(code, data, reply, option), SOFTBUS_TRANS_PROXY_READTOKEN_FAILED);
224 
225     data.WriteInterfaceToken(g_stub->GetDescriptor());
226     EXPECT_EQ(g_stub->OnRemoteRequest(code, data, reply, option), IPC_STUB_UNKNOW_TRANS_ERR);
227 
228     code = CLIENT_ON_PERMISSION_CHANGE;
229     data.WriteInterfaceToken(g_stub->GetDescriptor());
230     data.WriteInt32(0);
231     data.WriteCString("OnRemoteRequestTest");
232     EXPECT_EQ(g_stub->OnRemoteRequest(code, data, reply, option), SOFTBUS_OK);
233 }
234 
235 /**
236  * @tc.name: OnClientPermissonChangeInnerTest
237  * @tc.desc: OnClientPermissonChangeInnerTest, ReadInt32 faild return SOFTBUS_ERR
238  * @tc.desc: OnClientPermissonChangeInnerTest, ReadCString faild return SOFTBUS_ERR
239  * @tc.desc: OnClientPermissonChangeInnerTest, success return SOFTBUS_OK
240  * @tc.type: FUNC
241  * @tc.require:
242  */
HWTEST_F(SoftBusServerProxyFrameTest, OnClientPermissonChangeInnerTest, TestSize.Level1)243 HWTEST_F(SoftBusServerProxyFrameTest, OnClientPermissonChangeInnerTest, TestSize.Level1)
244 {
245     ASSERT_TRUE(g_stub != nullptr);
246     MessageParcel data;
247     MessageParcel reply;
248     EXPECT_EQ(g_stub->OnClientPermissonChangeInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
249 
250     data.WriteInt32(0);
251     EXPECT_EQ(g_stub->OnClientPermissonChangeInner(data, reply), SOFTBUS_TRANS_PROXY_READCSTRING_FAILED);
252 
253     data.WriteInt32(0);
254     data.WriteCString("OnClientPermissonChangeInnerTest");
255     EXPECT_EQ(g_stub->OnClientPermissonChangeInner(data, reply), SOFTBUS_OK);
256 }
257 
258 /**
259  * @tc.name: OnChannelOpenedInnerTest001
260  * @tc.desc: OnChannelOpenedInnerTest001, MessageParcel read failed return SOFTBUS_ERR
261  * @tc.type: FUNC
262  * @tc.require:
263  */
HWTEST_F(SoftBusServerProxyFrameTest, OnChannelOpenedInnerTest001, TestSize.Level1)264 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelOpenedInnerTest001, TestSize.Level1)
265 {
266     ASSERT_TRUE(g_stub != nullptr);
267     MessageParcel data;
268     MessageParcel reply;
269     MessageParcel tempData;
270     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
271 
272     data.WriteCString("OnChannelOpenedInnerTest");
273     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
274 
275     data.WriteCString("OnChannelOpenedInnerTest");
276     data.WriteInt32(0);
277     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
278 
279     data.WriteCString("OnChannelOpenedInnerTest");
280     data.WriteInt32(0);
281     data.WriteInt32(0);
282     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
283 
284     data.WriteCString("OnChannelOpenedInnerTest");
285     data.WriteInt32(0);
286     data.WriteInt32(0);
287     data.WriteBool(false);
288     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
289 
290     data.WriteCString("OnChannelOpenedInnerTest");
291     data.WriteInt32(0);
292     data.WriteInt32(0);
293     data.WriteBool(false);
294     data.WriteBool(true);
295     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
296 
297     data.WriteCString("OnChannelOpenedInnerTest");
298     data.WriteInt32(0);
299     data.WriteInt32(0);
300     data.WriteBool(false);
301     data.WriteBool(true);
302     data.WriteBool(false);
303     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
304 }
305 
306 /**
307  * @tc.name: OnChannelOpenedInnerTest002
308  * @tc.desc: OnChannelOpenedInnerTest002, MessageParcel read failed return SOFTBUS_ERR
309  * @tc.type: FUNC
310  * @tc.require:
311  */
HWTEST_F(SoftBusServerProxyFrameTest, OnChannelOpenedInnerTest002, TestSize.Level1)312 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelOpenedInnerTest002, TestSize.Level1)
313 {
314     ASSERT_TRUE(g_stub != nullptr);
315     MessageParcel data;
316     MessageParcel reply;
317 
318     data.WriteCString("OnChannelOpenedInnerTest");
319     data.WriteInt32(0);
320     data.WriteInt32(0);
321     data.WriteBool(false);
322     data.WriteBool(true);
323     data.WriteBool(false);
324     data.WriteInt32(0);
325     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
326 
327     data.WriteCString("OnChannelOpenedInnerTest");
328     data.WriteInt32(0);
329     data.WriteInt32(0);
330     data.WriteBool(false);
331     data.WriteBool(true);
332     data.WriteBool(false);
333     data.WriteInt32(0);
334     data.WriteInt32(0);
335     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
336 
337     data.WriteCString("OnChannelOpenedInnerTest");
338     data.WriteInt32(0);
339     data.WriteInt32(0);
340     data.WriteBool(false);
341     data.WriteBool(true);
342     data.WriteBool(false);
343     data.WriteInt32(0);
344     data.WriteInt32(0);
345     data.WriteCString("OnChannelOpenedInnerTest");
346     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
347 }
348 
349 /**
350  * @tc.name: OnChannelOpenFailedInnerTest
351  * @tc.desc: OnChannelOpenFailedInnerTest, ReadInt32 failed return SOFTBUS_ERR
352  * @tc.desc: OnChannelOpenFailedInnerTest, success return SOFTBUS_OK
353  * @tc.type: FUNC
354  * @tc.require:
355  */
HWTEST_F(SoftBusServerProxyFrameTest, OnChannelOpenFailedInnerTest, TestSize.Level1)356 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelOpenFailedInnerTest, TestSize.Level1)
357 {
358     ASSERT_TRUE(g_stub != nullptr);
359     MessageParcel data;
360     MessageParcel reply;
361     EXPECT_EQ(g_stub->OnChannelOpenFailedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
362 
363     data.WriteInt32(0);
364     EXPECT_EQ(g_stub->OnChannelOpenFailedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
365 
366     data.WriteInt32(0);
367     data.WriteInt32(99);
368     EXPECT_EQ(g_stub->OnChannelOpenFailedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
369 
370     data.WriteInt32(0);
371     data.WriteInt32(0);
372     data.WriteInt32(0);
373     EXPECT_EQ(g_stub->OnChannelOpenFailedInner(data, reply), SOFTBUS_OK);
374 }
375 
376 /**
377  * @tc.name: OnChannelLinkDownInnerTest
378  * @tc.desc: OnChannelLinkDownInnerTest, ReadCString failed return SOFTBUS_ERR
379  * @tc.desc: OnChannelLinkDownInnerTest, ReadInt32 failed return SOFTBUS_ERR
380  * @tc.desc: OnChannelLinkDownInnerTest, success return SOFTBUS_OK
381  * @tc.type: FUNC
382  * @tc.require:
383  */
HWTEST_F(SoftBusServerProxyFrameTest, OnChannelLinkDownInnerTest, TestSize.Level1)384 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelLinkDownInnerTest, TestSize.Level1)
385 {
386     ASSERT_TRUE(g_stub != nullptr);
387     MessageParcel data;
388     MessageParcel reply;
389     EXPECT_EQ(g_stub->OnChannelLinkDownInner(data, reply), SOFTBUS_TRANS_PROXY_READCSTRING_FAILED);
390 
391     data.WriteCString("OnChannelLinkDownInnerTest");
392     EXPECT_EQ(g_stub->OnChannelLinkDownInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
393 
394     data.WriteCString("OnChannelLinkDownInnerTest");
395     data.WriteInt32(0);
396     EXPECT_EQ(g_stub->OnChannelLinkDownInner(data, reply), SOFTBUS_OK);
397 }
398 
399 /**
400  * @tc.name: OnChannelClosedInnerTest
401  * @tc.desc: OnChannelClosedInnerTest, ReadInt32 failed return SOFTBUS_ERR
402  * @tc.desc: OnChannelClosedInnerTest, success return SOFTBUS_OK
403  * @tc.type: FUNC
404  * @tc.require:
405  */
HWTEST_F(SoftBusServerProxyFrameTest, OnChannelClosedInnerTest, TestSize.Level1)406 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelClosedInnerTest, TestSize.Level1)
407 {
408     ASSERT_TRUE(g_stub != nullptr);
409     MessageParcel data;
410     MessageParcel reply;
411     EXPECT_EQ(g_stub->OnChannelClosedInner(data, reply), SOFTBUS_IPC_ERR);
412 
413     data.WriteInt32(0);
414     EXPECT_EQ(g_stub->OnChannelClosedInner(data, reply), SOFTBUS_IPC_ERR);
415 
416     data.WriteInt32(0);
417     data.WriteInt32(0);
418     EXPECT_EQ(g_stub->OnChannelClosedInner(data, reply), SOFTBUS_IPC_ERR);
419 }
420 
421 /**
422  * @tc.name: OnChannelMsgReceivedInnerTest
423  * @tc.desc: OnChannelMsgReceivedInnerTest, MessageParcel failed return SOFTBUS_ERR
424  * @tc.desc: OnChannelMsgReceivedInnerTest, success return SOFTBUS_OK
425  * @tc.type: FUNC
426  * @tc.require:
427  */
HWTEST_F(SoftBusServerProxyFrameTest, OnChannelMsgReceivedInnerTest, TestSize.Level1)428 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelMsgReceivedInnerTest, TestSize.Level1)
429 {
430     ASSERT_TRUE(g_stub != nullptr);
431     MessageParcel data;
432     MessageParcel reply;
433     EXPECT_EQ(g_stub->OnChannelMsgReceivedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
434 
435     data.WriteInt32(0);
436     EXPECT_EQ(g_stub->OnChannelMsgReceivedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
437 
438     data.WriteInt32(0);
439     data.WriteInt32(0);
440     EXPECT_EQ(g_stub->OnChannelMsgReceivedInner(data, reply), SOFTBUS_TRANS_PROXY_READUINT_FAILED);
441 
442     data.WriteInt32(0);
443     data.WriteInt32(0);
444     data.WriteUint32(0);
445     EXPECT_EQ(g_stub->OnChannelMsgReceivedInner(data, reply), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED);
446 
447     std::string buffer = "OnChannelMsgReceivedInnerTest";
448     data.WriteInt32(0);
449     data.WriteInt32(0);
450     data.WriteUint32(buffer.size());
451     data.WriteRawData(buffer.c_str(), buffer.size());
452     EXPECT_EQ(g_stub->OnChannelMsgReceivedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
453 
454     data.WriteInt32(0);
455     data.WriteInt32(0);
456     data.WriteUint32(buffer.size());
457     data.WriteRawData(buffer.c_str(), buffer.size());
458     data.WriteInt32(0);
459     EXPECT_EQ(g_stub->OnChannelMsgReceivedInner(data, reply), SOFTBUS_OK);
460 }
461 
462 /**
463  * @tc.name: ISoftBusClientTest001
464  * @tc.desc: ISoftBusClientTest, use normal or wrong param
465  * @tc.type: FUNC
466  * @tc.require:
467  */
HWTEST_F(SoftBusServerProxyFrameTest, ISoftBusClientTest001, TestSize.Level1)468 HWTEST_F(SoftBusServerProxyFrameTest, ISoftBusClientTest001, TestSize.Level1)
469 {
470     ASSERT_TRUE(g_stub != nullptr);
471     int32_t testInt = 0;
472     uint32_t testUint = 0;
473     g_stub->OnPublishLNNResult(testInt, testInt);
474     g_stub->OnRefreshLNNResult(testInt, testInt);
475     g_stub->OnRefreshDeviceFound(nullptr, testUint);
476     g_stub->OnDataLevelChanged(nullptr, nullptr);
477     int32_t ret = g_stub->OnChannelOpened(nullptr, nullptr);
478     EXPECT_EQ(ret, SOFTBUS_OK);
479     ret = g_stub->OnChannelOpenFailed(testInt, testInt, testInt);
480     EXPECT_EQ(ret, SOFTBUS_OK);
481     ret = g_stub->OnChannelLinkDown(nullptr, testInt);
482     EXPECT_EQ(ret, SOFTBUS_OK);
483     ret = g_stub->OnChannelMsgReceived(testInt, testInt, nullptr, testUint, testInt);
484     EXPECT_EQ(ret, SOFTBUS_OK);
485     ret = g_stub->OnChannelClosed(testInt, testInt, testInt);
486     EXPECT_EQ(ret, SOFTBUS_OK);
487     ret = g_stub->OnChannelQosEvent(testInt, testInt, testInt, testInt, nullptr);
488     EXPECT_EQ(ret, SOFTBUS_OK);
489     ret = g_stub->SetChannelInfo(nullptr, testInt, testInt, testInt);
490     EXPECT_EQ(ret, SOFTBUS_OK);
491     ret = g_stub->OnJoinLNNResult(nullptr, testUint, nullptr, testInt);
492     EXPECT_EQ(ret, SOFTBUS_OK);
493     ret = g_stub->OnNodeOnlineStateChanged(nullptr, true, nullptr, testUint);
494     EXPECT_EQ(ret, SOFTBUS_OK);
495     ret = g_stub->OnNodeBasicInfoChanged(nullptr, nullptr, testUint, testInt);
496     EXPECT_EQ(ret, SOFTBUS_OK);
497     ret = g_stub->OnLocalNetworkIdChanged(nullptr);
498     EXPECT_EQ(ret, SOFTBUS_OK);
499     ret = g_stub->OnTimeSyncResult(nullptr, testUint, testInt);
500     EXPECT_EQ(ret, SOFTBUS_OK);
501     ret = g_stub->OnClientTransLimitChange(testInt, testUint);
502     EXPECT_EQ(ret, SOFTBUS_OK);
503     ret = g_stub->OnChannelBind(testInt, testInt);
504     EXPECT_EQ(ret, SOFTBUS_OK);
505 }
506 
507 /**
508  * @tc.name: OnRemoteDiedTest
509  * @tc.desc: OnRemoteDiedTest, use normal or wrong param
510  * @tc.type: FUNC
511  * @tc.require:
512  */
HWTEST_F(SoftBusServerProxyFrameTest, OnRemoteDiedTest, TestSize.Level1)513 HWTEST_F(SoftBusServerProxyFrameTest, OnRemoteDiedTest, TestSize.Level1)
514 {
515     ASSERT_TRUE(g_mock != nullptr);
516     g_mock->OnRemoteDied(nullptr);
517 }
518 } // namespace OHOS
519