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 "softbus_adapter_test.h"
17 #include "accesstoken_kit.h"
18 #include "nativetoken_kit.h"
19 #include "token_setproc.h"
20 
21 using namespace testing::ext;
22 
23 namespace OHOS {
24 namespace DistributedHardware {
25     namespace {
26     const std::string PEER_SESSION_NAME = "ohos.dhardware.dscreen.session8647073e02e7a78f09473aa125";
27     const std::string REMOTE_DEV_ID = "f6d4c0864707aefte7a78f09473aa122ff57fc81c00981fcf5be989e7d112125";
28     const std::string DSCREEN_PKG_NAME_TEST = "ohos.dhardware.dscreen";
29 }
SetUpTestCase(void)30 void SoftbusAdapterTest::SetUpTestCase(void) {}
31 
TearDownTestCase(void)32 void SoftbusAdapterTest::TearDownTestCase(void) {}
33 
SetUp(void)34 void SoftbusAdapterTest::SetUp(void) {}
35 
TearDown(void)36 void SoftbusAdapterTest::TearDown(void) {}
37 
EnablePermissionAccess(const char * perms[],size_t permsNum,uint64_t & tokenId)38 void EnablePermissionAccess(const char* perms[], size_t permsNum, uint64_t &tokenId)
39 {
40     NativeTokenInfoParams infoInstance = {
41         .dcapsNum = 0,
42         .permsNum = permsNum,
43         .aclsNum = 0,
44         .dcaps = nullptr,
45         .perms = perms,
46         .acls = nullptr,
47         .aplStr = "system_basic",
48     };
49 
50     infoInstance.processName = "SoftBusAdapterTest";
51     tokenId = GetAccessTokenId(&infoInstance);
52     SetSelfTokenID(tokenId);
53     OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
54 }
55 
DisablePermissionAccess(const uint64_t & tokenId)56 void DisablePermissionAccess(const uint64_t &tokenId)
57 {
58     OHOS::Security::AccessToken::AccessTokenKit::DeleteToken(tokenId);
59 }
60 
ScreenOnSoftbusSessionOpened(int32_t sessionId,PeerSocketInfo info)61 static void ScreenOnSoftbusSessionOpened(int32_t sessionId, PeerSocketInfo info) {}
62 
ScreenOnSoftbusSessionClosed(int32_t sessionId,ShutdownReason reason)63 static void ScreenOnSoftbusSessionClosed(int32_t sessionId, ShutdownReason reason) {}
64 
ScreenOnBytesReceived(int32_t sessionId,const void * data,uint32_t dataLen)65 static void ScreenOnBytesReceived(int32_t sessionId, const void *data, uint32_t dataLen) {}
66 
ScreenOnStreamReceived(int32_t sessionId,const StreamData * data,const StreamData * ext,const StreamFrameInfo * frameInfo)67 static void ScreenOnStreamReceived(int32_t sessionId, const StreamData *data, const StreamData *ext,
68     const StreamFrameInfo *frameInfo) {}
69 
ScreenOnMessageReceived(int sessionId,const void * data,unsigned int dataLen)70 static void ScreenOnMessageReceived(int sessionId, const void *data, unsigned int dataLen) {}
71 
72 /**
73  * @tc.name: CreateSoftbusSessionServer_001
74  * @tc.desc: Verify the CreateSoftbusSessionServer function.
75  * @tc.type: FUNC
76  * @tc.require: Issue Number
77  */
78 HWTEST_F(SoftbusAdapterTest, CreateSoftbusSessionServer_001, TestSize.Level1)
79 {
80     const char* perms[] = {
81         "ohos.permission.DISTRIBUTED_DATASYNC",
82         "ohos.permission.CAPTURE_SCREEN",
83     };
84     EnablePermissionAccess(perms, sizeof(perms) / sizeof(perms[0]), tokenId_);
85     softbusAdapter.sessListener_.OnBind = ScreenOnSoftbusSessionOpened;
86     softbusAdapter.sessListener_.OnShutdown = ScreenOnSoftbusSessionClosed;
87     softbusAdapter.sessListener_.OnBytes = ScreenOnBytesReceived;
88     softbusAdapter.sessListener_.OnStream = ScreenOnStreamReceived;
89     softbusAdapter.sessListener_.OnMessage = ScreenOnMessageReceived;
90 
91     std::string pkgname = PKG_NAME;
92     std::string sessionName = DATA_SESSION_NAME;
93     std::string peerDevId = "peerDevId";
94     int32_t sessionId = 0;
95     void *data = nullptr;
96     uint32_t dataLen = 0;
97     StreamData sData;
98     sData.bufLen = 0;
99     sData.buf = reinterpret_cast<char*>(&dataLen);
100     StreamData *streamData = nullptr;
101     StreamData *ext = nullptr;
102     StreamFrameInfo *frameInfo = nullptr;
103     softbusAdapter.OnBytesReceived(sessionId, data, dataLen);
104     softbusAdapter.OnStreamReceived(sessionId, streamData, ext, frameInfo);
105     data = reinterpret_cast<void*>(&dataLen);
106     streamData = &sData;
107     softbusAdapter.OnBytesReceived(sessionId, data, dataLen);
108     softbusAdapter.OnStreamReceived(sessionId, streamData, ext, frameInfo);
109     dataLen = DSCREEN_MAX_RECV_DATA_LEN + 1;
110     sData.bufLen = DSCREEN_MAX_RECV_DATA_LEN + 1;
111     softbusAdapter.OnBytesReceived(sessionId, data, dataLen);
112     softbusAdapter.OnStreamReceived(sessionId, streamData, ext, frameInfo);
113     dataLen = 100;
114     sData.bufLen = 100;
115     softbusAdapter.OnBytesReceived(sessionId, data, dataLen);
116     softbusAdapter.OnStreamReceived(sessionId, streamData, ext, frameInfo);
117     int32_t actual = softbusAdapter.CreateSoftbusSessionServer(pkgname, sessionName, peerDevId);
118     EXPECT_EQ(DH_SUCCESS, actual);
119     softbusAdapter.RemoveSoftbusSessionServer(pkgname, sessionName, peerDevId);
120     DisablePermissionAccess(tokenId_);
121 }
122 
123 /**
124  * @tc.name: CreateSoftbusSessionServer_002
125  * @tc.desc: Verify the CreateSoftbusSessionServer function.
126  * @tc.type: FUNC
127  * @tc.require: Issue Number
128  */
129 HWTEST_F(SoftbusAdapterTest, CreateSoftbusSessionServer_002, TestSize.Level1)
130 {
131     softbusAdapter.serverIdMap_.clear();
132     std::string pkgname = PKG_NAME;
133     std::string sessionName = DATA_SESSION_NAME;
134     std::string peerDevId = "peerDevId";
135 
136     int32_t actual = softbusAdapter.CreateSoftbusSessionServer(pkgname, sessionName, peerDevId);
137     EXPECT_EQ(DH_SUCCESS, actual);
138     softbusAdapter.RemoveSoftbusSessionServer(pkgname, sessionName, peerDevId);
139 }
140 
141 /**
142  * @tc.name: CreateSoftbusSessionServer_003
143  * @tc.desc: Verify the CreateSoftbusSessionServer function.
144  * @tc.type: FUNC
145  * @tc.require: Issue Number
146  */
147 HWTEST_F(SoftbusAdapterTest, CreateSoftbusSessionServer_003, TestSize.Level1)
148 {
149     std::string pkgName = "ohos.dhardware.dscreentest";
150     std::string sessionName = DATA_SESSION_NAME;
151     std::string peerDevId = "peerDevId";
152     softbusAdapter.serverIdMap_.clear();
153     softbusAdapter.serverIdMap_.insert(std::make_pair(100000, sessionName + "_" + peerDevId));
154     int32_t actual = softbusAdapter.CreateSoftbusSessionServer(pkgName, sessionName, peerDevId);
155     EXPECT_EQ(DH_SUCCESS, actual);
156 }
157 
158 /**
159  * @tc.name: CreateSoftbusSessionServer_004
160  * @tc.desc: Verify the CreateSoftbusSessionServer function.
161  * @tc.type: FUNC
162  * @tc.require: Issue Number
163  */
164 HWTEST_F(SoftbusAdapterTest, CreateSoftbusSessionServer_004, TestSize.Level1)
165 {
166     std::string pkgName = "ohos.dhardware.dscreentest";
167     std::string sessionName = DATA_SESSION_NAME;
168     std::string peerDevId = "peerDevId";
169     softbusAdapter.serverIdMap_.clear();
170     softbusAdapter.serverIdMap_.insert(std::make_pair(100000, sessionName + "__" + peerDevId));
171     int32_t actual = softbusAdapter.CreateSoftbusSessionServer(pkgName, sessionName, peerDevId);
172     EXPECT_EQ(ERR_DH_SCREEN_ADAPTER_BAD_VALUE, actual);
173 }
174 
175 /**
176  * @tc.name: RegisterSoftbusListener_001
177  * @tc.desc: Verify the RegisterSoftbusListener function.
178  * @tc.type: FUNC
179  * @tc.require: Issue Number
180  */
181 HWTEST_F(SoftbusAdapterTest, RegisterSoftbusListener_001, TestSize.Level1)
182 {
183     std::shared_ptr<ISoftbusListener> listener = std::make_shared<MockSoftbusListener>();
184     std::string sessionName = DATA_SESSION_NAME;
185     std::string peerDevId = "testDevId";
186 
187     int32_t actual = softbusAdapter.RegisterSoftbusListener(listener, sessionName, peerDevId);
188     EXPECT_EQ(DH_SUCCESS, actual);
189 
190     actual = softbusAdapter.UnRegisterSoftbusListener(sessionName, peerDevId);
191     EXPECT_EQ(DH_SUCCESS, actual);
192 }
193 
194 /**
195  * @tc.name: RegisterSoftbusListener_002
196  * @tc.desc: Verify the RegisterSoftbusListener function.
197  * @tc.type: FUNC
198  * @tc.require: Issue Number
199  */
200 HWTEST_F(SoftbusAdapterTest, RegisterSoftbusListener_002, TestSize.Level1)
201 {
202     std::shared_ptr<ISoftbusListener> listener = std::make_shared<MockSoftbusListener>();
203     std::string sessionName = DATA_SESSION_NAME;
204     std::string peerDevId = "testDevId";
205 
206     int32_t actual = softbusAdapter.RegisterSoftbusListener(listener, sessionName, peerDevId);
207     EXPECT_EQ(DH_SUCCESS, actual);
208 
209     actual = softbusAdapter.RegisterSoftbusListener(listener, sessionName, peerDevId);
210     EXPECT_EQ(ERR_DH_SCREEN_ADAPTER_REGISTER_SOFTBUS_LISTENER_FAIL, actual);
211 }
212 
213 /**
214  * @tc.name: RegisterSoftbusListener_003
215  * @tc.desc: Verify the RegisterSoftbusListener function.
216  * @tc.type: FUNC
217  * @tc.require: Issue Number
218  */
219 HWTEST_F(SoftbusAdapterTest, RegisterSoftbusListener_003, TestSize.Level1)
220 {
221     std::shared_ptr<ISoftbusListener> listener = nullptr;
222     std::string sessionName = DATA_SESSION_NAME;
223     std::string peerDevId = "testDevId";
224 
225     int32_t actual = softbusAdapter.RegisterSoftbusListener(listener, sessionName, peerDevId);
226     EXPECT_EQ(ERR_DH_SCREEN_ADAPTER_REGISTER_SOFTBUS_LISTENER_FAIL, actual);
227 }
228 
229 /**
230  * @tc.name: UnRegisterSoftbusListener_001
231  * @tc.desc: Verify the UnRegisterSoftbusListener function.
232  * @tc.type: FUNC
233  * @tc.require: Issue Number
234  */
235 HWTEST_F(SoftbusAdapterTest, UnRegisterSoftbusListener_001, TestSize.Level1)
236 {
237     std::string sessionName = DATA_SESSION_NAME;
238     std::string peerDevId = "testDevId";
239 
240     int32_t actual = softbusAdapter.UnRegisterSoftbusListener(sessionName, peerDevId);
241 
242     EXPECT_EQ(DH_SUCCESS, actual);
243 }
244 
245 /**
246  * @tc.name: RemoveSoftbusSessionServer_001
247  * @tc.desc: Verify the RemoveSoftbusSessionServer function.
248  * @tc.type: FUNC
249  * @tc.require: Issue Number
250  */
251 HWTEST_F(SoftbusAdapterTest, RemoveSoftbusSessionServer_001, TestSize.Level1)
252 {
253     std::string pkgname = "";
254     std::string sessionName = "";
255     std::string peerDevId = "";
256 
257     int32_t actual = softbusAdapter.RemoveSoftbusSessionServer(pkgname, sessionName, peerDevId);
258 
259     EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual);
260 }
261 
262 /**
263  * @tc.name: RemoveSoftbusSessionServer_002
264  * @tc.desc: Verify the RemoveSoftbusSessionServer function.
265  * @tc.type: FUNC
266  * @tc.require: Issue Number
267  */
268 HWTEST_F(SoftbusAdapterTest, RemoveSoftbusSessionServer_002, TestSize.Level1)
269 {
270     std::string pkgname = PKG_NAME;
271     std::string sessionName = DATA_SESSION_NAME;
272     std::string peerDevId = "peerDevId";
273 
274     int32_t actual = softbusAdapter.RemoveSoftbusSessionServer(pkgname, sessionName, peerDevId);
275     EXPECT_EQ(DH_SUCCESS, actual);
276 }
277 
278 /**
279  * @tc.name: OpenSoftbusSession_001
280  * @tc.desc: Verify the OpenSoftbusSession function.
281  * @tc.type: FUNC
282  * @tc.require: Issue Number
283  */
284 HWTEST_F(SoftbusAdapterTest, OpenSoftbusSession_001, TestSize.Level1)
285 {
286     std::string mySessionName = DATA_SESSION_NAME;
287     std::string peerSessionName = DATA_SESSION_NAME;
288     std::string peerDevId = "testDevId";
289     int32_t actual = softbusAdapter.OpenSoftbusSession(mySessionName, peerSessionName, peerDevId);
290     EXPECT_EQ(ERR_DH_SCREEN_ADAPTER_PARA_ERROR, actual);
291 }
292 
293 /**
294  * @tc.name: CloseSoftbusSession_001
295  * @tc.desc: Verify the CloseSoftbusSession function.
296  * @tc.type: FUNC
297  * @tc.require: Issue Number
298  */
299 HWTEST_F(SoftbusAdapterTest, CloseSoftbusSession_001, TestSize.Level1)
300 {
301     int32_t actual = softbusAdapter.CloseSoftbusSession(0);
302     EXPECT_EQ(DH_SUCCESS, actual);
303 }
304 
305 /**
306  * @tc.name: SendSoftbusBytes_001
307  * @tc.desc: Verify the SendSoftbusBytes function.
308  * @tc.type: FUNC
309  * @tc.require: Issue Number
310  */
311 HWTEST_F(SoftbusAdapterTest, SendSoftbusBytes_001, TestSize.Level1)
312 {
313     int32_t sessionId = 0;
314     void *data = nullptr;
315     int32_t dataLen = 0;
316     int32_t actual = softbusAdapter.SendSoftbusBytes(sessionId, data, dataLen);
317     EXPECT_EQ(ERR_DH_SCREEN_TRANS_ERROR, actual);
318 }
319 
320 /**
321  * @tc.name: SendSoftbusStream_001
322  * @tc.desc: Verify the SendSoftbusStream function.
323  * @tc.type: FUNC
324  * @tc.require: Issue Number
325  */
326 HWTEST_F(SoftbusAdapterTest, SendSoftbusStream_001, TestSize.Level1)
327 {
328     int32_t sessionId = 0;
329     StreamData *data = nullptr;
330     StreamData *ext = nullptr;
331     StreamFrameInfo *param = nullptr;
332     int32_t actual = softbusAdapter.SendSoftbusStream(sessionId, data, ext, param);
333     EXPECT_EQ(ERR_DH_SCREEN_TRANS_ERROR, actual);
334 }
335 
336 /**
337  * @tc.name: GetSoftbusListener_001
338  * @tc.desc: Verify the GetSoftbusListener function.
339  * @tc.type: FUNC
340  * @tc.require: Issue Number
341  */
342 HWTEST_F(SoftbusAdapterTest, GetSoftbusListener_001, TestSize.Level1)
343 {
344     int32_t sessionId = 0;
345     SessionInfo sessionInfo;
346     sessionInfo.sessionName = "hello";
347     sessionInfo.peerDevId = "world";
348     std::shared_ptr<ISoftbusListener> listener = nullptr;
349     softbusAdapter.mapListeners_["hello_world"] = listener;
350     std::shared_ptr<ISoftbusListener> actual = softbusAdapter.GetSoftbusListenerById(sessionId);
351     EXPECT_EQ(nullptr, actual);
352 }
353 
354 /**
355  * @tc.name: OnSoftbusSessionOpened_001
356  * @tc.desc: Verify the OnSoftbusSessionOpened function.
357  * @tc.type: FUNC
358  * @tc.require: Issue Number
359  */
360 HWTEST_F(SoftbusAdapterTest, OnSoftbusSessionOpened_001, TestSize.Level1)
361 {
362     PeerSocketInfo peerSocketInfo = {
363         .name = const_cast<char*>(PEER_SESSION_NAME.c_str()),
364         .networkId = const_cast<char*>(REMOTE_DEV_ID.c_str()),
365         .pkgName = const_cast<char*>(DSCREEN_PKG_NAME_TEST.c_str()),
366         .dataType = DATA_TYPE_BYTES
367     };
368     int32_t actual = softbusAdapter.OnSoftbusSessionOpened(0, peerSocketInfo);
369     EXPECT_EQ(ERR_DH_SCREEN_TRANS_ERROR, actual);
370 }
371 
372 /**
373  * @tc.name: GetSoftbusListenerById_001
374  * @tc.desc: Verify the GetSoftbusListenerById function.
375  * @tc.type: FUNC
376  * @tc.require: Issue Number
377  */
378 HWTEST_F(SoftbusAdapterTest, GetSoftbusListenerById_001, TestSize.Level1)
379 {
380     int32_t sessionId = 0;
381     softbusAdapter.mapSessListeners_[sessionId] = nullptr;
382     std::shared_ptr<ISoftbusListener> listener = softbusAdapter.GetSoftbusListenerById(sessionId);
383     EXPECT_EQ(nullptr, listener);
384 }
385 } // DistributedHardware
386 } // OHOS