1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 
18 #include <condition_variable>
19 #include <mutex>
20 #include <chrono>
21 
22 #include "connection/screen_session_ability_connection.h"
23 #include "extension_manager_client.h"
24 #include "ipc_skeleton.h"
25 #include "scene_board_judgement.h"
26 
27 using namespace testing;
28 using namespace testing::ext;
29 
30 namespace OHOS {
31 namespace Rosen {
32 constexpr int32_t DEFAULT_VALUE = -1;
33 constexpr uint32_t EXTENSION_CONNECT_OUT_TIME = 300; // ms
34 constexpr uint32_t TRANS_CMD_SEND_SNAPSHOT_RECT = 2;
35 namespace {
36     constexpr uint32_t SLEEP_TIME_US = 100000;
37 }
38 
39 class ScreenSessionAbilityConnectionTest : public testing::Test {
40 public:
41     static void SetUpTestCase();
42     static void TearDownTestCase();
43     void SetUp() override;
44     void TearDown() override;
45     std::recursive_mutex mutex_;
46 
47 private:
48     std::mutex connectedMutex_;
49     std::condition_variable connectedCv_;
50 };
51 
SetUpTestCase()52 void ScreenSessionAbilityConnectionTest::SetUpTestCase()
53 {
54 }
55 
TearDownTestCase()56 void ScreenSessionAbilityConnectionTest::TearDownTestCase()
57 {
58 }
59 
SetUp()60 void ScreenSessionAbilityConnectionTest::SetUp()
61 {
62 }
63 
TearDown()64 void ScreenSessionAbilityConnectionTest::TearDown()
65 {
66     usleep(SLEEP_TIME_US);
67 }
68 
69 namespace {
70 
71 /**
72  * @tc.name: OnAbilityConnectDone
73  * @tc.desc: OnAbilityConnectDone func test
74  * @tc.type: FUNC
75  */
76 HWTEST_F(ScreenSessionAbilityConnectionTest, OnAbilityConnectDone, Function | SmallTest | Level1)
77 {
78     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
79         new (std::nothrow) ScreenSessionAbilityConnectionStub());
80     ASSERT_NE(abilityConnectionStub, nullptr);
81     AAFwk::Want want;
82     want.SetElementName("com.ohos.sceneboard",
83         "com.ohos.sceneboard.systemdialog");
84     std::string identity = IPCSkeleton::ResetCallingIdentity();
85     auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
86         want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
87     IPCSkeleton::SetCallingIdentity(identity);
88     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
89         ASSERT_EQ(resConnect, ERR_OK);
90         {
91             std::unique_lock<std::mutex> lock(connectedMutex_);
92             static_cast<void>(connectedCv_.wait_for(lock, std::chrono::milliseconds(EXTENSION_CONNECT_OUT_TIME)));
93         }
94         auto resDisconnect = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
95         ASSERT_EQ(resDisconnect, NO_ERROR);
96     } else {
97         ASSERT_NE(resConnect, ERR_OK);
98     }
99     abilityConnectionStub.clear();
100     abilityConnectionStub = nullptr;
101 }
102 
103 /**
104  * @tc.name: OnAbilityDisconnectDone
105  * @tc.desc: OnAbilityDisconnectDone func
106  * @tc.type: FUNC
107  */
108 HWTEST_F(ScreenSessionAbilityConnectionTest, OnAbilityDisconnectDone, Function | SmallTest | Level1)
109 {
110     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
111         new (std::nothrow) ScreenSessionAbilityConnectionStub());
112     ASSERT_NE(abilityConnectionStub, nullptr);
113     AAFwk::Want want;
114     want.SetElementName("com.ohos.sceneboard",
115         "com.ohos.sceneboard.systemdialog");
116     std::string identity = IPCSkeleton::ResetCallingIdentity();
117     auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
118         want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
119     IPCSkeleton::SetCallingIdentity(identity);
120     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
121         ASSERT_EQ(resConnect, ERR_OK);
122         AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
123         EXPECT_EQ(abilityConnectionStub->IsAbilityConnected(), false);
124     } else {
125         ASSERT_NE(resConnect, ERR_OK);
126     }
127     abilityConnectionStub.clear();
128     abilityConnectionStub = nullptr;
129 }
130 
131 /**
132  * @tc.name: IsAbilityConnected
133  * @tc.desc: IsAbilityConnected func
134  * @tc.type: FUNC
135  */
136 HWTEST_F(ScreenSessionAbilityConnectionTest, IsAbilityConnected, Function | SmallTest | Level1)
137 {
138     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
139         new (std::nothrow) ScreenSessionAbilityConnectionStub());
140     ASSERT_NE(abilityConnectionStub, nullptr);
141     EXPECT_EQ(abilityConnectionStub->IsAbilityConnected(), false);
142     abilityConnectionStub.clear();
143     abilityConnectionStub = nullptr;
144 }
145 
146 /**
147  * @tc.name: SendMessageSync
148  * @tc.desc: SendMessageSync func
149  * @tc.type: FUNC
150  */
151 HWTEST_F(ScreenSessionAbilityConnectionTest, SendMessageSync, Function | SmallTest | Level1)
152 {
153     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
154         new (std::nothrow) ScreenSessionAbilityConnectionStub());
155     ASSERT_NE(abilityConnectionStub, nullptr);
156     AAFwk::Want want;
157     want.SetElementName("com.ohos.sceneboard",
158         "com.ohos.sceneboard.systemdialog");
159     std::string identity = IPCSkeleton::ResetCallingIdentity();
160     auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
161         want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
162     IPCSkeleton::SetCallingIdentity(identity);
163     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
164         ASSERT_EQ(resConnect, ERR_OK);
165         {
166             std::unique_lock<std::mutex> lock(connectedMutex_);
167             static_cast<void>(connectedCv_.wait_for(lock, std::chrono::milliseconds(EXTENSION_CONNECT_OUT_TIME)));
168         }
169         MessageParcel data;
170         MessageParcel reply;
171         data.WriteString16(Str8ToStr16("SA"));
172         data.WriteString16(Str8ToStr16("ScreenSessionManager"));
173         abilityConnectionStub->SendMessageSync(TRANS_CMD_SEND_SNAPSHOT_RECT, data, reply);
174         EXPECT_EQ(reply.ReadInt32(), 0);
175         EXPECT_EQ(reply.ReadInt32(), 0);
176         EXPECT_EQ(reply.ReadInt32(), 0);
177         EXPECT_EQ(reply.ReadInt32(), 0);
178         EXPECT_EQ(reply.ReadInt32(), 0);
179         auto resDisconnect = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
180         ASSERT_EQ(resDisconnect, NO_ERROR);
181     } else {
182         ASSERT_NE(resConnect, ERR_OK);
183     }
184     abilityConnectionStub.clear();
185     abilityConnectionStub = nullptr;
186 }
187 
188 /**
189  * @tc.name: OnRemoteDied
190  * @tc.desc: OnRemoteDied func
191  * @tc.type: FUNC
192  */
193 HWTEST_F(ScreenSessionAbilityConnectionTest, OnRemoteDied, Function | SmallTest | Level1)
194 {
195     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
196         new (std::nothrow) ScreenSessionAbilityConnectionStub());
197     ASSERT_NE(abilityConnectionStub, nullptr);
198     AAFwk::Want want;
199     want.SetElementName("com.ohos.sceneboard",
200         "com.ohos.sceneboard.systemdialog");
201     std::string identity = IPCSkeleton::ResetCallingIdentity();
202     auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
203         want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
204     IPCSkeleton::SetCallingIdentity(identity);
205     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
206         ASSERT_EQ(resConnect, ERR_OK);
207         AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
208         EXPECT_EQ(abilityConnectionStub->IsAbilityConnected(), false);
209     } else {
210         ASSERT_NE(resConnect, ERR_OK);
211     }
212     abilityConnectionStub.clear();
213     abilityConnectionStub = nullptr;
214 }
215 
216 /**
217  * @tc.name: IsAbilityConnectedSync
218  * @tc.desc: IsAbilityConnectedSync func
219  * @tc.type: FUNC
220  */
221 HWTEST_F(ScreenSessionAbilityConnectionTest, IsAbilityConnectedSync, Function | SmallTest | Level1)
222 {
223     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
224         new (std::nothrow) ScreenSessionAbilityConnectionStub());
225     ASSERT_NE(abilityConnectionStub, nullptr);
226     EXPECT_EQ(abilityConnectionStub->IsAbilityConnectedSync(), false);
227     abilityConnectionStub.clear();
228     abilityConnectionStub = nullptr;
229 }
230 
231 /**
232  * @tc.name: ScreenSessionConnectExtension
233  * @tc.desc: ScreenSessionConnectExtension func
234  * @tc.type: FUNC
235  */
236 HWTEST_F(ScreenSessionAbilityConnectionTest, ScreenSessionConnectExtension, Function | SmallTest | Level1)
237 {
238     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
239         new (std::nothrow) ScreenSessionAbilityConnectionStub());
240     ASSERT_NE(abilityConnectionStub, nullptr);
241     AAFwk::Want want;
242     const std::string bundleName = "com.ohos.sceneboard";
243     const std::string abilityName = "com.ohos.sceneboard.systemdialog";
244     want.SetElementName(bundleName, abilityName);
245     std::string identity = IPCSkeleton::ResetCallingIdentity();
246     auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
247         want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
248     IPCSkeleton::SetCallingIdentity(identity);
249     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
250         ASSERT_EQ(resConnect, ERR_OK);
251     } else {
252         ASSERT_NE(resConnect, ERR_OK);
253     }
254     abilityConnectionStub.clear();
255     abilityConnectionStub = nullptr;
256 }
257 
258 /**
259  * @tc.name: ScreenSessionConnectExtension02
260  * @tc.desc: ScreenSessionConnectExtension02 func
261  * @tc.type: FUNC
262  */
263 HWTEST_F(ScreenSessionAbilityConnectionTest, ScreenSessionConnectExtension02, Function | SmallTest | Level1)
264 {
265     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
266         new (std::nothrow) ScreenSessionAbilityConnectionStub());
267     ASSERT_NE(abilityConnectionStub, nullptr);
268     AAFwk::Want want;
269     const std::string bundleName = "com.ohos.sceneboard";
270     const std::string abilityName = "com.ohos.sceneboard.systemdialog";
271     want.SetElementName(bundleName, abilityName);
272     std::string paramKey = "requestReason";
273     std::string paramValue = "onPlugIn";
274     want.SetParam(paramKey, paramValue);
275     std::string identity = IPCSkeleton::ResetCallingIdentity();
276     auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
277         want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
278     IPCSkeleton::SetCallingIdentity(identity);
279     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
280         ASSERT_EQ(resConnect, ERR_OK);
281     } else {
282         ASSERT_NE(resConnect, ERR_OK);
283     }
284     abilityConnectionStub.clear();
285     abilityConnectionStub = nullptr;
286 }
287 
288 /**
289  * @tc.name: ScreenSessionDisconnectExtension
290  * @tc.desc: ScreenSessionDisconnectExtension func test
291  * @tc.type: FUNC
292  */
293 HWTEST_F(ScreenSessionAbilityConnectionTest, ScreenSessionDisconnectExtension, Function | SmallTest | Level1)
294 {
295     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
296         new (std::nothrow) ScreenSessionAbilityConnectionStub());
297     ASSERT_NE(abilityConnectionStub, nullptr);
298     AAFwk::Want want;
299     want.SetElementName("com.ohos.sceneboard",
300         "com.ohos.sceneboard.systemdialog");
301     std::string identity = IPCSkeleton::ResetCallingIdentity();
302     auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
303         want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
304     IPCSkeleton::SetCallingIdentity(identity);
305     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
306         ASSERT_EQ(resConnect, ERR_OK);
307         {
308             std::unique_lock<std::mutex> lock(connectedMutex_);
309             static_cast<void>(connectedCv_.wait_for(lock, std::chrono::milliseconds(EXTENSION_CONNECT_OUT_TIME)));
310         }
311         auto resDisconnect = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
312         ASSERT_EQ(resDisconnect, NO_ERROR);
313     } else {
314         ASSERT_NE(resConnect, ERR_OK);
315     }
316     abilityConnectionStub.clear();
317     abilityConnectionStub = nullptr;
318 }
319 
320 /**
321  * @tc.name: SendMessage
322  * @tc.desc: SendMessage func test
323  * @tc.type: FUNC
324  */
325 HWTEST_F(ScreenSessionAbilityConnectionTest, SendMessage, Function | SmallTest | Level1)
326 {
327     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
328         new (std::nothrow) ScreenSessionAbilityConnectionStub());
329     ASSERT_NE(abilityConnectionStub, nullptr);
330     AAFwk::Want want;
331     want.SetElementName("com.ohos.sceneboard",
332         "com.ohos.sceneboard.systemdialog");
333     std::string identity = IPCSkeleton::ResetCallingIdentity();
334     auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
335         want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
336     IPCSkeleton::SetCallingIdentity(identity);
337     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
338         ASSERT_EQ(resConnect, ERR_OK);
339         {
340             std::unique_lock<std::mutex> lock(connectedMutex_);
341             static_cast<void>(connectedCv_.wait_for(lock, std::chrono::milliseconds(EXTENSION_CONNECT_OUT_TIME)));
342         }
343         MessageParcel data;
344         MessageParcel reply;
345         data.WriteString16(Str8ToStr16("SA"));
346         data.WriteString16(Str8ToStr16("ScreenSessionManager"));
347         abilityConnectionStub->SendMessageSync(TRANS_CMD_SEND_SNAPSHOT_RECT, data, reply);
348         EXPECT_EQ(reply.ReadInt32(), 0);
349         EXPECT_EQ(reply.ReadInt32(), 0);
350         EXPECT_EQ(reply.ReadInt32(), 0);
351         EXPECT_EQ(reply.ReadInt32(), 0);
352         EXPECT_EQ(reply.ReadInt32(), 0);
353         auto resDisconnect = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
354         ASSERT_EQ(resDisconnect, NO_ERROR);
355     } else {
356         ASSERT_NE(resConnect, ERR_OK);
357     }
358     abilityConnectionStub.clear();
359     abilityConnectionStub = nullptr;
360 }
361 
362 /**
363  * @tc.name: SendMessageBlock
364  * @tc.desc: SendMessageBlock func test
365  * @tc.type: FUNC
366  */
367 HWTEST_F(ScreenSessionAbilityConnectionTest, SendMessageBlock, Function | SmallTest | Level1)
368 {
369     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
370         new (std::nothrow) ScreenSessionAbilityConnectionStub());
371     ASSERT_NE(abilityConnectionStub, nullptr);
372     AAFwk::Want want;
373     want.SetElementName("com.ohos.sceneboard",
374         "com.ohos.sceneboard.systemdialog");
375     std::string identity = IPCSkeleton::ResetCallingIdentity();
376     auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
377         want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
378     IPCSkeleton::SetCallingIdentity(identity);
379     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
380         ASSERT_EQ(resConnect, ERR_OK);
381         {
382             std::unique_lock<std::mutex> lock(connectedMutex_);
383             static_cast<void>(connectedCv_.wait_for(lock, std::chrono::milliseconds(EXTENSION_CONNECT_OUT_TIME)));
384         }
385         MessageParcel data;
386         MessageParcel reply;
387         data.WriteString16(Str8ToStr16("SA"));
388         data.WriteString16(Str8ToStr16("ScreenSessionManager"));
389         abilityConnectionStub->SendMessageSyncBlock(TRANS_CMD_SEND_SNAPSHOT_RECT, data, reply);
390         EXPECT_EQ(reply.ReadInt32(), 0);
391         EXPECT_EQ(reply.ReadInt32(), 0);
392         EXPECT_EQ(reply.ReadInt32(), 0);
393         EXPECT_EQ(reply.ReadInt32(), 0);
394         EXPECT_EQ(reply.ReadInt32(), 0);
395         auto resDisconnect = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
396         ASSERT_EQ(resDisconnect, NO_ERROR);
397     } else {
398         ASSERT_NE(resConnect, ERR_OK);
399     }
400     abilityConnectionStub.clear();
401     abilityConnectionStub = nullptr;
402 }
403 
404 /**
405  * @tc.name: OnRemoteRequest
406  * @tc.desc: OnRemoteRequest func test
407  * @tc.type: FUNC
408  */
409 HWTEST_F(ScreenSessionAbilityConnectionTest, OnRemoteRequest, Function | SmallTest | Level1)
410 {
411     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
412         new (std::nothrow) ScreenSessionAbilityConnectionStub());
413     ASSERT_NE(abilityConnectionStub, nullptr);
414     AAFwk::Want want;
415     want.SetElementName("com.ohos.sceneboard",
416         "com.ohos.sceneboard.systemdialog");
417     std::string identity = IPCSkeleton::ResetCallingIdentity();
418     auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
419         want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
420     IPCSkeleton::SetCallingIdentity(identity);
421     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
422         ASSERT_EQ(resConnect, ERR_OK);
423         {
424             std::unique_lock<std::mutex> lock(connectedMutex_);
425             static_cast<void>(connectedCv_.wait_for(lock, std::chrono::milliseconds(EXTENSION_CONNECT_OUT_TIME)));
426         }
427         MessageParcel data;
428         MessageParcel reply;
429         MessageOption option;
430         data.WriteString16(Str8ToStr16("SA"));
431         data.WriteString16(Str8ToStr16("ScreenSessionManager"));
432         abilityConnectionStub->OnRemoteRequest(TRANS_CMD_SEND_SNAPSHOT_RECT, data, reply, option);
433         EXPECT_EQ(reply.ReadInt32(), 0);
434         EXPECT_EQ(reply.ReadInt32(), 0);
435         EXPECT_EQ(reply.ReadInt32(), 0);
436         EXPECT_EQ(reply.ReadInt32(), 0);
437         EXPECT_EQ(reply.ReadInt32(), 0);
438         auto resDisconnect = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
439         ASSERT_EQ(resDisconnect, NO_ERROR);
440     } else {
441         ASSERT_NE(resConnect, ERR_OK);
442     }
443     abilityConnectionStub.clear();
444     abilityConnectionStub = nullptr;
445 }
446 
447 /**
448  * @tc.name: GetScreenId
449  * @tc.desc: GetScreenId func test
450  * @tc.type: FUNC
451  */
452 HWTEST_F(ScreenSessionAbilityConnectionTest, GetScreenId, Function | SmallTest | Level1)
453 {
454     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
455         new (std::nothrow) ScreenSessionAbilityConnectionStub());
456     ASSERT_NE(abilityConnectionStub, nullptr);
457     int32_t expection = 0;
458     EXPECT_EQ(abilityConnectionStub->GetScreenId(), expection);
459     abilityConnectionStub.clear();
460     abilityConnectionStub = nullptr;
461 }
462 
463 /**
464  * @tc.name: GetLeft
465  * @tc.desc: GetLeft func test
466  * @tc.type: FUNC
467  */
468 HWTEST_F(ScreenSessionAbilityConnectionTest, GetLeft, Function | SmallTest | Level1)
469 {
470     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
471         new (std::nothrow) ScreenSessionAbilityConnectionStub());
472     ASSERT_NE(abilityConnectionStub, nullptr);
473     int32_t expection = 0;
474     EXPECT_EQ(abilityConnectionStub->GetLeft(), expection);
475     abilityConnectionStub.clear();
476     abilityConnectionStub = nullptr;
477 }
478 
479 /**
480  * @tc.name: GetTop
481  * @tc.desc: GetTop func test
482  * @tc.type: FUNC
483  */
484 HWTEST_F(ScreenSessionAbilityConnectionTest, GetTop, Function | SmallTest | Level1)
485 {
486     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
487         new (std::nothrow) ScreenSessionAbilityConnectionStub());
488     ASSERT_NE(abilityConnectionStub, nullptr);
489     int32_t expection = 0;
490     EXPECT_EQ(abilityConnectionStub->GetTop(), expection);
491     abilityConnectionStub.clear();
492     abilityConnectionStub = nullptr;
493 }
494 
495 /**
496  * @tc.name: GetWidth
497  * @tc.desc: GetWidth func test
498  * @tc.type: FUNC
499  */
500 HWTEST_F(ScreenSessionAbilityConnectionTest, GetWidth, Function | SmallTest | Level1)
501 {
502     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
503         new (std::nothrow) ScreenSessionAbilityConnectionStub());
504     ASSERT_NE(abilityConnectionStub, nullptr);
505     int32_t expection = 0;
506     EXPECT_EQ(abilityConnectionStub->GetWidth(), expection);
507     abilityConnectionStub.clear();
508     abilityConnectionStub = nullptr;
509 }
510 
511 /**
512  * @tc.name: GetHeight
513  * @tc.desc: GetHeight func test
514  * @tc.type: FUNC
515  */
516 HWTEST_F(ScreenSessionAbilityConnectionTest, GetHeight, Function | SmallTest | Level1)
517 {
518     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
519         new (std::nothrow) ScreenSessionAbilityConnectionStub());
520     ASSERT_NE(abilityConnectionStub, nullptr);
521     int32_t expection = 0;
522     EXPECT_EQ(abilityConnectionStub->GetHeight(), expection);
523     abilityConnectionStub.clear();
524     abilityConnectionStub = nullptr;
525 }
526 
527 /**
528  * @tc.name: GetErrCode
529  * @tc.desc: GetErrCode func test
530  * @tc.type: FUNC
531  */
532 HWTEST_F(ScreenSessionAbilityConnectionTest, GetErrCode, Function | SmallTest | Level1)
533 {
534     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
535         new (std::nothrow) ScreenSessionAbilityConnectionStub());
536     ASSERT_NE(abilityConnectionStub, nullptr);
537     uint32_t expection = 0;
538     EXPECT_EQ(abilityConnectionStub->GetErrCode(), expection);
539     abilityConnectionStub.clear();
540     abilityConnectionStub = nullptr;
541 }
542 
543 /**
544  * @tc.name: EraseErrCode
545  * @tc.desc: EraseErrCode func test
546  * @tc.type: FUNC
547  */
548 HWTEST_F(ScreenSessionAbilityConnectionTest, EraseErrCode, Function | SmallTest | Level1)
549 {
550     sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
551         new (std::nothrow) ScreenSessionAbilityConnectionStub());
552     ASSERT_NE(abilityConnectionStub, nullptr);
553     abilityConnectionStub->errCode_ = 1;
554     uint32_t expection = 0;
555     abilityConnectionStub->EraseErrCode();
556     EXPECT_EQ(abilityConnectionStub->errCode_, expection);
557     abilityConnectionStub.clear();
558     abilityConnectionStub = nullptr;
559 }
560 }
561 } // namespace Rosen
562 } // namespace OHOS