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 SoftBusClientStubMock : public SoftBusClientStub {
41 public:
42     int32_t OnChannelOpenFailed([[maybe_unused]] int32_t channelId, [[maybe_unused]] int32_t channelType,
43         [[maybe_unused]] int32_t errCode) override
44     {
45         return SOFTBUS_OK;
46     }
47     int32_t OnChannelBind([[maybe_unused]] int32_t channelId, [[maybe_unused]] int32_t channelType) override
48     {
49         return SOFTBUS_OK;
50     }
51     int32_t OnChannelLinkDown([[maybe_unused]] const char *networkId, [[maybe_unused]] int32_t routeType) override
52     {
53         return SOFTBUS_OK;
54     }
55     int32_t OnChannelClosed([[maybe_unused]] int32_t channelId, [[maybe_unused]] int32_t channelType,
56         [[maybe_unused]] int32_t messageType) override
57     {
58         return SOFTBUS_OK;
59     }
60     int32_t OnChannelMsgReceived([[maybe_unused]] int32_t channelId, [[maybe_unused]] int32_t channelType,
61         [[maybe_unused]] const void *data, [[maybe_unused]] uint32_t len, [[maybe_unused]] int32_t type) override
62     {
63         return SOFTBUS_OK;
64     }
65     int32_t SetChannelInfo([[maybe_unused]]const char *sessionName, [[maybe_unused]] int32_t sessionId,
66         [[maybe_unused]] int32_t channelId, [[maybe_unused]] int32_t channelType) override
67     {
68         return SOFTBUS_OK;
69     }
70 };
71 
72 namespace {
73 sptr<SoftBusClientStubMock> g_stub = nullptr;
74 }
75 
SetUpTestCase()76 void SoftBusServerProxyFrameTest::SetUpTestCase()
77 {
78     g_stub = new (std::nothrow) SoftBusClientStubMock();
79 }
80 
TearDownTestCase()81 void SoftBusServerProxyFrameTest::TearDownTestCase()
82 {
83     g_stub = nullptr;
84 }
85 
86 /**
87  * @tc.name: InnerRegisterServiceTest
88  * @tc.desc: InnerRegisterServiceTest, Initialization failure
89  * @tc.desc: InnerRegisterServiceTest, Successful initialization
90  * @tc.type: FUNC
91  * @tc.require:
92  */
93 HWTEST_F(SoftBusServerProxyFrameTest, InnerRegisterServiceTest, TestSize.Level1)
94 {
95     EXPECT_EQ(InnerRegisterService(NULL), SOFTBUS_INVALID_PARAM);
96 
97     EXPECT_EQ(ServerProxyInit(), SOFTBUS_OK);
98     EXPECT_EQ(InitSoftBus("SoftBusServerProxyFrameTest"), SOFTBUS_NO_INIT);
99     EXPECT_EQ(InnerRegisterService(NULL), SOFTBUS_TRANS_GET_CLIENT_NAME_FAILED);
100 
101     ListNode sessionServerList;
102     ListInit(&sessionServerList);
103     EXPECT_EQ(InnerRegisterService(&sessionServerList), SOFTBUS_TRANS_GET_CLIENT_NAME_FAILED);
104 }
105 
106 /**
107  * @tc.name: GetSystemAbilityTest
108  * @tc.desc: GetSystemAbilityTest, Get interface return is not empty
109  * @tc.type: FUNC
110  * @tc.require:
111  */
112 HWTEST_F(SoftBusServerProxyFrameTest, GetSystemAbilityTest, TestSize.Level1)
113 {
114     EXPECT_TRUE(GetSystemAbility() != nullptr);
115 }
116 
117 /**
118  * @tc.name: ClientRegisterServiceTest
119  * @tc.desc: ClientRegisterServiceTest, Initializing registration succeeded. Procedure
120  * @tc.type: FUNC
121  * @tc.require:
122  */
123 HWTEST_F(SoftBusServerProxyFrameTest, ClientRegisterServiceTest, TestSize.Level1)
124 {
125     EXPECT_EQ(ServerProxyInit(), SOFTBUS_OK);
126     EXPECT_EQ(ClientRegisterService("ClientRegisterServiceTest"), SOFTBUS_SERVER_NOT_INIT);
127 }
128 
129 /**
130  * @tc.name: ClientStubInitTest
131  * @tc.desc: ClientStubInitTest, Successful initialization
132  * @tc.type: FUNC
133  * @tc.require:
134  */
135 HWTEST_F(SoftBusServerProxyFrameTest, ClientStubInitTest, TestSize.Level1)
136 {
137     EXPECT_EQ(ClientStubInit(), SOFTBUS_OK);
138 }
139 
140 /**
141  * @tc.name: SoftbusRegisterServiceTest
142  * @tc.desc: SoftbusRegisterServiceTest, remote is nullptr return SOFTBUS_ERR
143  * @tc.desc: SoftbusRegisterServiceTest, SoftbusRegisterService success return SOFTBUS_OK
144  * @tc.desc: SoftbusRegisterServiceTest, clientPkgName is nullptr return SOFTBUS_ERR
145  * @tc.type: FUNC
146  * @tc.require:
147  */
148 HWTEST_F(SoftBusServerProxyFrameTest, SoftbusRegisterServiceTest, TestSize.Level1)
149 {
150     sptr<SoftBusServerProxyFrame> serverProxyFrame = new (std::nothrow) SoftBusServerProxyFrame(nullptr);
151     ASSERT_TRUE(serverProxyFrame != nullptr);
152     EXPECT_EQ(serverProxyFrame->SoftbusRegisterService("SoftbusRegisterServiceTest", nullptr), SOFTBUS_IPC_ERR);
153 
154     sptr<IRemoteObject> serverProxy = GetSystemAbility();
155     ASSERT_TRUE(serverProxy != nullptr);
156     serverProxyFrame = new (std::nothrow) SoftBusServerProxyFrame(serverProxy);
157     ASSERT_TRUE(serverProxyFrame != nullptr);
158     EXPECT_EQ(serverProxyFrame->SoftbusRegisterService("SoftbusRegisterServiceTest", nullptr), SOFTBUS_IPC_ERR);
159 
160     EXPECT_EQ(serverProxyFrame->SoftbusRegisterService(nullptr, nullptr), SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED);
161 }
162 
163 /**
164  * @tc.name: OnRemoteRequestTest
165  * @tc.desc: OnRemoteRequestTest, ReadInterfaceToken faild return SOFTBUS_ERR
166  * @tc.desc: OnRemoteRequestTest, OnRemoteRequest Call default return IPC_STUB_UNKNOW_TRANS_ERR
167  * @tc.desc: OnRemoteRequestTest, OnRemoteRequest Call CLIENT_ON_PERMISSION_CHANGE
168  * @tc.type: FUNC
169  * @tc.require:
170  */
171 HWTEST_F(SoftBusServerProxyFrameTest, OnRemoteRequestTest, TestSize.Level1)
172 {
173     ASSERT_TRUE(g_stub != nullptr);
174     uint32_t code = 0;
175     MessageParcel data;
176     MessageParcel reply;
177     MessageOption option;
178     EXPECT_EQ(g_stub->OnRemoteRequest(code, data, reply, option), SOFTBUS_TRANS_PROXY_READTOKEN_FAILED);
179 
180     data.WriteInterfaceToken(g_stub->GetDescriptor());
181     EXPECT_EQ(g_stub->OnRemoteRequest(code, data, reply, option), IPC_STUB_UNKNOW_TRANS_ERR);
182 
183     code = CLIENT_ON_PERMISSION_CHANGE;
184     data.WriteInterfaceToken(g_stub->GetDescriptor());
185     data.WriteInt32(0);
186     data.WriteCString("OnRemoteRequestTest");
187     EXPECT_EQ(g_stub->OnRemoteRequest(code, data, reply, option), SOFTBUS_OK);
188 }
189 
190 /**
191  * @tc.name: OnClientPermissonChangeInnerTest
192  * @tc.desc: OnClientPermissonChangeInnerTest, ReadInt32 faild return SOFTBUS_ERR
193  * @tc.desc: OnClientPermissonChangeInnerTest, ReadCString faild return SOFTBUS_ERR
194  * @tc.desc: OnClientPermissonChangeInnerTest, success return SOFTBUS_OK
195  * @tc.type: FUNC
196  * @tc.require:
197  */
198 HWTEST_F(SoftBusServerProxyFrameTest, OnClientPermissonChangeInnerTest, TestSize.Level1)
199 {
200     ASSERT_TRUE(g_stub != nullptr);
201     MessageParcel data;
202     MessageParcel reply;
203     EXPECT_EQ(g_stub->OnClientPermissonChangeInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
204 
205     data.WriteInt32(0);
206     EXPECT_EQ(g_stub->OnClientPermissonChangeInner(data, reply), SOFTBUS_TRANS_PROXY_READCSTRING_FAILED);
207 
208     data.WriteInt32(0);
209     data.WriteCString("OnClientPermissonChangeInnerTest");
210     EXPECT_EQ(g_stub->OnClientPermissonChangeInner(data, reply), SOFTBUS_OK);
211 }
212 
213 /**
214  * @tc.name: OnChannelOpenedInnerTest001
215  * @tc.desc: OnChannelOpenedInnerTest001, MessageParcel read failed return SOFTBUS_ERR
216  * @tc.type: FUNC
217  * @tc.require:
218  */
219 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelOpenedInnerTest001, TestSize.Level1)
220 {
221     ASSERT_TRUE(g_stub != nullptr);
222     MessageParcel data;
223     MessageParcel reply;
224     MessageParcel tempData;
225     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
226 
227     data.WriteCString("OnChannelOpenedInnerTest");
228     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
229 
230     data.WriteCString("OnChannelOpenedInnerTest");
231     data.WriteInt32(0);
232     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
233 
234     data.WriteCString("OnChannelOpenedInnerTest");
235     data.WriteInt32(0);
236     data.WriteInt32(0);
237     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
238 
239     data.WriteCString("OnChannelOpenedInnerTest");
240     data.WriteInt32(0);
241     data.WriteInt32(0);
242     data.WriteBool(false);
243     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
244 
245     data.WriteCString("OnChannelOpenedInnerTest");
246     data.WriteInt32(0);
247     data.WriteInt32(0);
248     data.WriteBool(false);
249     data.WriteBool(true);
250     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
251 
252     data.WriteCString("OnChannelOpenedInnerTest");
253     data.WriteInt32(0);
254     data.WriteInt32(0);
255     data.WriteBool(false);
256     data.WriteBool(true);
257     data.WriteBool(false);
258     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
259 }
260 
261 /**
262  * @tc.name: OnChannelOpenedInnerTest002
263  * @tc.desc: OnChannelOpenedInnerTest002, MessageParcel read failed return SOFTBUS_ERR
264  * @tc.type: FUNC
265  * @tc.require:
266  */
267 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelOpenedInnerTest002, TestSize.Level1)
268 {
269     ASSERT_TRUE(g_stub != nullptr);
270     MessageParcel data;
271     MessageParcel reply;
272 
273     data.WriteCString("OnChannelOpenedInnerTest");
274     data.WriteInt32(0);
275     data.WriteInt32(0);
276     data.WriteBool(false);
277     data.WriteBool(true);
278     data.WriteBool(false);
279     data.WriteInt32(0);
280     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
281 
282     data.WriteCString("OnChannelOpenedInnerTest");
283     data.WriteInt32(0);
284     data.WriteInt32(0);
285     data.WriteBool(false);
286     data.WriteBool(true);
287     data.WriteBool(false);
288     data.WriteInt32(0);
289     data.WriteInt32(0);
290     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
291 
292     data.WriteCString("OnChannelOpenedInnerTest");
293     data.WriteInt32(0);
294     data.WriteInt32(0);
295     data.WriteBool(false);
296     data.WriteBool(true);
297     data.WriteBool(false);
298     data.WriteInt32(0);
299     data.WriteInt32(0);
300     data.WriteCString("OnChannelOpenedInnerTest");
301     EXPECT_EQ(g_stub->OnChannelOpenedInner(data, reply), SOFTBUS_IPC_ERR);
302 }
303 
304 /**
305  * @tc.name: OnChannelOpenFailedInnerTest
306  * @tc.desc: OnChannelOpenFailedInnerTest, ReadInt32 failed return SOFTBUS_ERR
307  * @tc.desc: OnChannelOpenFailedInnerTest, success return SOFTBUS_OK
308  * @tc.type: FUNC
309  * @tc.require:
310  */
311 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelOpenFailedInnerTest, TestSize.Level1)
312 {
313     ASSERT_TRUE(g_stub != nullptr);
314     MessageParcel data;
315     MessageParcel reply;
316     EXPECT_EQ(g_stub->OnChannelOpenFailedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
317 
318     data.WriteInt32(0);
319     EXPECT_EQ(g_stub->OnChannelOpenFailedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
320 
321     data.WriteInt32(0);
322     data.WriteInt32(99);
323     EXPECT_EQ(g_stub->OnChannelOpenFailedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
324 
325     data.WriteInt32(0);
326     data.WriteInt32(0);
327     data.WriteInt32(0);
328     EXPECT_EQ(g_stub->OnChannelOpenFailedInner(data, reply), SOFTBUS_OK);
329 }
330 
331 /**
332  * @tc.name: OnChannelLinkDownInnerTest
333  * @tc.desc: OnChannelLinkDownInnerTest, ReadCString failed return SOFTBUS_ERR
334  * @tc.desc: OnChannelLinkDownInnerTest, ReadInt32 failed return SOFTBUS_ERR
335  * @tc.desc: OnChannelLinkDownInnerTest, success return SOFTBUS_OK
336  * @tc.type: FUNC
337  * @tc.require:
338  */
339 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelLinkDownInnerTest, TestSize.Level1)
340 {
341     ASSERT_TRUE(g_stub != nullptr);
342     MessageParcel data;
343     MessageParcel reply;
344     EXPECT_EQ(g_stub->OnChannelLinkDownInner(data, reply), SOFTBUS_TRANS_PROXY_READCSTRING_FAILED);
345 
346     data.WriteCString("OnChannelLinkDownInnerTest");
347     EXPECT_EQ(g_stub->OnChannelLinkDownInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
348 
349     data.WriteCString("OnChannelLinkDownInnerTest");
350     data.WriteInt32(0);
351     EXPECT_EQ(g_stub->OnChannelLinkDownInner(data, reply), SOFTBUS_OK);
352 }
353 
354 /**
355  * @tc.name: OnChannelClosedInnerTest
356  * @tc.desc: OnChannelClosedInnerTest, ReadInt32 failed return SOFTBUS_ERR
357  * @tc.desc: OnChannelClosedInnerTest, success return SOFTBUS_OK
358  * @tc.type: FUNC
359  * @tc.require:
360  */
361 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelClosedInnerTest, TestSize.Level1)
362 {
363     ASSERT_TRUE(g_stub != nullptr);
364     MessageParcel data;
365     MessageParcel reply;
366     EXPECT_EQ(g_stub->OnChannelClosedInner(data, reply), SOFTBUS_IPC_ERR);
367 
368     data.WriteInt32(0);
369     EXPECT_EQ(g_stub->OnChannelClosedInner(data, reply), SOFTBUS_IPC_ERR);
370 
371     data.WriteInt32(0);
372     data.WriteInt32(0);
373     EXPECT_EQ(g_stub->OnChannelClosedInner(data, reply), SOFTBUS_IPC_ERR);
374 }
375 
376 /**
377  * @tc.name: OnChannelMsgReceivedInnerTest
378  * @tc.desc: OnChannelMsgReceivedInnerTest, MessageParcel failed return SOFTBUS_ERR
379  * @tc.desc: OnChannelMsgReceivedInnerTest, success return SOFTBUS_OK
380  * @tc.type: FUNC
381  * @tc.require:
382  */
383 HWTEST_F(SoftBusServerProxyFrameTest, OnChannelMsgReceivedInnerTest, TestSize.Level1)
384 {
385     ASSERT_TRUE(g_stub != nullptr);
386     MessageParcel data;
387     MessageParcel reply;
388     EXPECT_EQ(g_stub->OnChannelMsgReceivedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
389 
390     data.WriteInt32(0);
391     EXPECT_EQ(g_stub->OnChannelMsgReceivedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
392 
393     data.WriteInt32(0);
394     data.WriteInt32(0);
395     EXPECT_EQ(g_stub->OnChannelMsgReceivedInner(data, reply), SOFTBUS_TRANS_PROXY_READUINT_FAILED);
396 
397     data.WriteInt32(0);
398     data.WriteInt32(0);
399     data.WriteUint32(0);
400     EXPECT_EQ(g_stub->OnChannelMsgReceivedInner(data, reply), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED);
401 
402     std::string buffer = "OnChannelMsgReceivedInnerTest";
403     data.WriteInt32(0);
404     data.WriteInt32(0);
405     data.WriteUint32(buffer.size());
406     data.WriteRawData(buffer.c_str(), buffer.size());
407     EXPECT_EQ(g_stub->OnChannelMsgReceivedInner(data, reply), SOFTBUS_TRANS_PROXY_READINT_FAILED);
408 
409     data.WriteInt32(0);
410     data.WriteInt32(0);
411     data.WriteUint32(buffer.size());
412     data.WriteRawData(buffer.c_str(), buffer.size());
413     data.WriteInt32(0);
414     EXPECT_EQ(g_stub->OnChannelMsgReceivedInner(data, reply), SOFTBUS_OK);
415 }
416 } // namespace OHOS
417