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 constexpr int32_t RES_FAILURE = -1;
36 namespace {
37 constexpr uint32_t SLEEP_TIME_US = 100000;
38 }
39
40 class ScreenSessionAbilityConnectionUtTest : public testing::Test {
41 public:
42 static void SetUpTestCase();
43 static void TearDownTestCase();
44 void SetUp() override;
45 void TearDown() override;
46 std::recursive_mutex mutex_;
47
48 private:
49 std::mutex connectedMutex_;
50 std::condition_variable connectedCv_;
51 };
52
SetUpTestCase()53 void ScreenSessionAbilityConnectionUtTest::SetUpTestCase()
54 {
55 }
56
TearDownTestCase()57 void ScreenSessionAbilityConnectionUtTest::TearDownTestCase()
58 {
59 }
60
SetUp()61 void ScreenSessionAbilityConnectionUtTest::SetUp()
62 {
63 }
64
TearDown()65 void ScreenSessionAbilityConnectionUtTest::TearDown()
66 {
67 usleep(SLEEP_TIME_US);
68 }
69
70 namespace {
71
72 /**
73 * @tc.name: OnAbilityConnectDone
74 * @tc.desc: OnAbilityConnectDone func test
75 * @tc.type: FUNC
76 */
77 HWTEST_F(ScreenSessionAbilityConnectionUtTest, OnAbilityConnectDone, TestSize.Level1)
78 {
79 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
80 new (std::nothrow) ScreenSessionAbilityConnectionStub());
81 ASSERT_NE(abilityConnectionStub, nullptr);
82 AAFwk::Want want;
83 want.SetElementName("com.ohos.sceneboard",
84 "com.ohos.sceneboard.systemdialog");
85 std::string identity = IPCSkeleton::ResetCallingIdentity();
86 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
87 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
88 IPCSkeleton::SetCallingIdentity(identity);
89 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
90 ASSERT_EQ(resConnect, ERR_OK);
91 {
92 std::unique_lock<std::mutex> lock(connectedMutex_);
93 static_cast<void>(connectedCv_.wait_for(lock, std::chrono::milliseconds(EXTENSION_CONNECT_OUT_TIME)));
94 }
95 auto resDisconnect = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
96 ASSERT_EQ(resDisconnect, NO_ERROR);
97 } else {
98 ASSERT_NE(resConnect, ERR_OK);
99 }
100 abilityConnectionStub.clear();
101 abilityConnectionStub = nullptr;
102 }
103
104 /**
105 * @tc.name: OnAbilityDisconnectDone
106 * @tc.desc: OnAbilityDisconnectDone func
107 * @tc.type: FUNC
108 */
109 HWTEST_F(ScreenSessionAbilityConnectionUtTest, OnAbilityDisconnectDone, TestSize.Level1)
110 {
111 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
112 new (std::nothrow) ScreenSessionAbilityConnectionStub());
113 ASSERT_NE(abilityConnectionStub, nullptr);
114 AAFwk::Want want;
115 want.SetElementName("com.ohos.sceneboard",
116 "com.ohos.sceneboard.systemdialog");
117 std::string identity = IPCSkeleton::ResetCallingIdentity();
118 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
119 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
120 IPCSkeleton::SetCallingIdentity(identity);
121 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
122 ASSERT_EQ(resConnect, ERR_OK);
123 AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
124 EXPECT_EQ(abilityConnectionStub->IsAbilityConnected(), false);
125 } else {
126 ASSERT_NE(resConnect, ERR_OK);
127 }
128 abilityConnectionStub.clear();
129 abilityConnectionStub = nullptr;
130 }
131
132 /**
133 * @tc.name: AddObjectDeathRecipient
134 * @tc.desc: AddObjectDeathRecipient func
135 * @tc.type: FUNC
136 */
137 HWTEST_F(ScreenSessionAbilityConnectionUtTest, AddObjectDeathRecipient, TestSize.Level1)
138 {
139 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
140 new (std::nothrow) ScreenSessionAbilityConnectionStub());
141 ASSERT_NE(abilityConnectionStub, nullptr);
142 EXPECT_EQ(abilityConnectionStub->AddObjectDeathRecipient(), false);
143 abilityConnectionStub.clear();
144 abilityConnectionStub = nullptr;
145 }
146
147 /**
148 * @tc.name: SendMessage
149 * @tc.desc: SendMessage func test02
150 * @tc.type: FUNC
151 */
152 HWTEST_F(ScreenSessionAbilityConnectionUtTest, SendMessage02, TestSize.Level1)
153 {
154 ScreenSessionAbilityConnection screenSessionAbilityConnection;
155 int32_t transCode = 0;
156 MessageParcel data;
157 MessageParcel reply;
158 auto ret = screenSessionAbilityConnection.SendMessage(transCode, data, reply);
159 EXPECT_EQ(ret, RES_FAILURE);
160 }
161
162 /**
163 * @tc.name: IsConnected
164 * @tc.desc: IsConnected func
165 * @tc.type: FUNC
166 */
167 HWTEST_F(ScreenSessionAbilityConnectionUtTest, IsConnected, TestSize.Level1)
168 {
169 ScreenSessionAbilityConnection screenSessionAbilityConnection;
170 auto ret = screenSessionAbilityConnection.IsConnected();
171 EXPECT_EQ(ret, false);
172 }
173
174 /**
175 * @tc.name: IsAbilityConnected
176 * @tc.desc: IsAbilityConnected func
177 * @tc.type: FUNC
178 */
179 HWTEST_F(ScreenSessionAbilityConnectionUtTest, IsAbilityConnected, TestSize.Level1)
180 {
181 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
182 new (std::nothrow) ScreenSessionAbilityConnectionStub());
183 ASSERT_NE(abilityConnectionStub, nullptr);
184 EXPECT_EQ(abilityConnectionStub->IsAbilityConnected(), false);
185 abilityConnectionStub.clear();
186 abilityConnectionStub = nullptr;
187 }
188
189 /**
190 * @tc.name: SendMessageSync
191 * @tc.desc: SendMessageSync func
192 * @tc.type: FUNC
193 */
194 HWTEST_F(ScreenSessionAbilityConnectionUtTest, SendMessageSync, TestSize.Level1)
195 {
196 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
197 new (std::nothrow) ScreenSessionAbilityConnectionStub());
198 ASSERT_NE(abilityConnectionStub, nullptr);
199 AAFwk::Want want;
200 want.SetElementName("com.ohos.sceneboard",
201 "com.ohos.sceneboard.systemdialog");
202 std::string identity = IPCSkeleton::ResetCallingIdentity();
203 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
204 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
205 IPCSkeleton::SetCallingIdentity(identity);
206 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
207 ASSERT_EQ(resConnect, ERR_OK);
208 {
209 std::unique_lock<std::mutex> lock(connectedMutex_);
210 static_cast<void>(connectedCv_.wait_for(lock, std::chrono::milliseconds(EXTENSION_CONNECT_OUT_TIME)));
211 }
212 MessageParcel data;
213 MessageParcel reply;
214 data.WriteString16(Str8ToStr16("SA"));
215 data.WriteString16(Str8ToStr16("ScreenSessionManager"));
216 abilityConnectionStub->SendMessageSync(TRANS_CMD_SEND_SNAPSHOT_RECT, data, reply);
217 EXPECT_EQ(reply.ReadInt32(), 0);
218 EXPECT_EQ(reply.ReadInt32(), 0);
219 EXPECT_EQ(reply.ReadInt32(), 0);
220 EXPECT_EQ(reply.ReadInt32(), 0);
221 EXPECT_EQ(reply.ReadInt32(), 0);
222 auto resDisconnect = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
223 ASSERT_EQ(resDisconnect, NO_ERROR);
224 } else {
225 ASSERT_NE(resConnect, ERR_OK);
226 }
227 abilityConnectionStub.clear();
228 abilityConnectionStub = nullptr;
229 }
230
231 /**
232 * @tc.name: OnRemoteDied
233 * @tc.desc: OnRemoteDied func
234 * @tc.type: FUNC
235 */
236 HWTEST_F(ScreenSessionAbilityConnectionUtTest, OnRemoteDied, TestSize.Level1)
237 {
238 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
239 new (std::nothrow) ScreenSessionAbilityConnectionStub());
240 ASSERT_NE(abilityConnectionStub, nullptr);
241 AAFwk::Want want;
242 want.SetElementName("com.ohos.sceneboard",
243 "com.ohos.sceneboard.systemdialog");
244 std::string identity = IPCSkeleton::ResetCallingIdentity();
245 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
246 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
247 IPCSkeleton::SetCallingIdentity(identity);
248 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
249 ASSERT_EQ(resConnect, ERR_OK);
250 AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
251 EXPECT_EQ(abilityConnectionStub->IsAbilityConnected(), false);
252 } else {
253 ASSERT_NE(resConnect, ERR_OK);
254 }
255 abilityConnectionStub.clear();
256 abilityConnectionStub = nullptr;
257 }
258
259 /**
260 * @tc.name: IsAbilityConnectedSync
261 * @tc.desc: IsAbilityConnectedSync func
262 * @tc.type: FUNC
263 */
264 HWTEST_F(ScreenSessionAbilityConnectionUtTest, IsAbilityConnectedSync, TestSize.Level1)
265 {
266 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
267 new (std::nothrow) ScreenSessionAbilityConnectionStub());
268 ASSERT_NE(abilityConnectionStub, nullptr);
269 EXPECT_EQ(abilityConnectionStub->IsAbilityConnectedSync(), false);
270 abilityConnectionStub.clear();
271 abilityConnectionStub = nullptr;
272 }
273
274 /**
275 * @tc.name: ScreenSessionConnectExtension
276 * @tc.desc: ScreenSessionConnectExtension func
277 * @tc.type: FUNC
278 */
279 HWTEST_F(ScreenSessionAbilityConnectionUtTest, ScreenSessionConnectExtension, TestSize.Level1)
280 {
281 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
282 new (std::nothrow) ScreenSessionAbilityConnectionStub());
283 ASSERT_NE(abilityConnectionStub, nullptr);
284 AAFwk::Want want;
285 const std::string bundleName = "com.ohos.sceneboard";
286 const std::string abilityName = "com.ohos.sceneboard.systemdialog";
287 want.SetElementName(bundleName, abilityName);
288 std::string identity = IPCSkeleton::ResetCallingIdentity();
289 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
290 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
291 IPCSkeleton::SetCallingIdentity(identity);
292 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
293 ASSERT_EQ(resConnect, ERR_OK);
294 } else {
295 ASSERT_NE(resConnect, ERR_OK);
296 }
297 abilityConnectionStub.clear();
298 abilityConnectionStub = nullptr;
299 }
300
301 /**
302 * @tc.name: ScreenSessionConnectExtension02
303 * @tc.desc: ScreenSessionConnectExtension02 func
304 * @tc.type: FUNC
305 */
306 HWTEST_F(ScreenSessionAbilityConnectionUtTest, ScreenSessionConnectExtension02, TestSize.Level1)
307 {
308 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
309 new (std::nothrow) ScreenSessionAbilityConnectionStub());
310 ASSERT_NE(abilityConnectionStub, nullptr);
311 AAFwk::Want want;
312 const std::string bundleName = "com.ohos.sceneboard";
313 const std::string abilityName = "com.ohos.sceneboard.systemdialog";
314 want.SetElementName(bundleName, abilityName);
315 std::string paramKey = "requestReason";
316 std::string paramValue = "onPlugIn";
317 want.SetParam(paramKey, paramValue);
318 std::string identity = IPCSkeleton::ResetCallingIdentity();
319 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
320 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
321 IPCSkeleton::SetCallingIdentity(identity);
322 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
323 ASSERT_EQ(resConnect, ERR_OK);
324 } else {
325 ASSERT_NE(resConnect, ERR_OK);
326 }
327 abilityConnectionStub.clear();
328 abilityConnectionStub = nullptr;
329 }
330
331 /**
332 * @tc.name: ScreenSessionDisconnectExtension
333 * @tc.desc: ScreenSessionDisconnectExtension func test
334 * @tc.type: FUNC
335 */
336 HWTEST_F(ScreenSessionAbilityConnectionUtTest, ScreenSessionDisconnectExtension, TestSize.Level1)
337 {
338 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
339 new (std::nothrow) ScreenSessionAbilityConnectionStub());
340 ASSERT_NE(abilityConnectionStub, nullptr);
341 AAFwk::Want want;
342 want.SetElementName("com.ohos.sceneboard",
343 "com.ohos.sceneboard.systemdialog");
344 std::string identity = IPCSkeleton::ResetCallingIdentity();
345 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
346 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
347 IPCSkeleton::SetCallingIdentity(identity);
348 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
349 ASSERT_EQ(resConnect, ERR_OK);
350 {
351 std::unique_lock<std::mutex> lock(connectedMutex_);
352 static_cast<void>(connectedCv_.wait_for(lock, std::chrono::milliseconds(EXTENSION_CONNECT_OUT_TIME)));
353 }
354 auto resDisconnect = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
355 ASSERT_EQ(resDisconnect, NO_ERROR);
356 } else {
357 ASSERT_NE(resConnect, ERR_OK);
358 }
359 abilityConnectionStub.clear();
360 abilityConnectionStub = nullptr;
361 }
362
363 /**
364 * @tc.name: SendMessage
365 * @tc.desc: SendMessage func test
366 * @tc.type: FUNC
367 */
368 HWTEST_F(ScreenSessionAbilityConnectionUtTest, SendMessage, TestSize.Level1)
369 {
370 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
371 new (std::nothrow) ScreenSessionAbilityConnectionStub());
372 ASSERT_NE(abilityConnectionStub, nullptr);
373 AAFwk::Want want;
374 want.SetElementName("com.ohos.sceneboard",
375 "com.ohos.sceneboard.systemdialog");
376 std::string identity = IPCSkeleton::ResetCallingIdentity();
377 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
378 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
379 IPCSkeleton::SetCallingIdentity(identity);
380 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
381 ASSERT_EQ(resConnect, ERR_OK);
382 {
383 std::unique_lock<std::mutex> lock(connectedMutex_);
384 static_cast<void>(connectedCv_.wait_for(lock, std::chrono::milliseconds(EXTENSION_CONNECT_OUT_TIME)));
385 }
386 MessageParcel data;
387 MessageParcel reply;
388 data.WriteString16(Str8ToStr16("SA"));
389 data.WriteString16(Str8ToStr16("ScreenSessionManager"));
390 abilityConnectionStub->SendMessageSync(TRANS_CMD_SEND_SNAPSHOT_RECT, data, reply);
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 EXPECT_EQ(reply.ReadInt32(), 0);
396 auto resDisconnect = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
397 ASSERT_EQ(resDisconnect, NO_ERROR);
398 } else {
399 ASSERT_NE(resConnect, ERR_OK);
400 }
401 abilityConnectionStub.clear();
402 abilityConnectionStub = nullptr;
403 }
404
405 /**
406 * @tc.name: SendMessageBlock
407 * @tc.desc: SendMessageBlock func test
408 * @tc.type: FUNC
409 */
410 HWTEST_F(ScreenSessionAbilityConnectionUtTest, SendMessageBlock, TestSize.Level1)
411 {
412 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
413 new (std::nothrow) ScreenSessionAbilityConnectionStub());
414 ASSERT_NE(abilityConnectionStub, nullptr);
415 AAFwk::Want want;
416 want.SetElementName("com.ohos.sceneboard",
417 "com.ohos.sceneboard.systemdialog");
418 std::string identity = IPCSkeleton::ResetCallingIdentity();
419 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
420 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
421 IPCSkeleton::SetCallingIdentity(identity);
422 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
423 ASSERT_EQ(resConnect, ERR_OK);
424 {
425 std::unique_lock<std::mutex> lock(connectedMutex_);
426 static_cast<void>(connectedCv_.wait_for(lock, std::chrono::milliseconds(EXTENSION_CONNECT_OUT_TIME)));
427 }
428 MessageParcel data;
429 MessageParcel reply;
430 data.WriteString16(Str8ToStr16("SA"));
431 data.WriteString16(Str8ToStr16("ScreenSessionManager"));
432 abilityConnectionStub->SendMessageSyncBlock(TRANS_CMD_SEND_SNAPSHOT_RECT, data, reply);
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: OnRemoteRequest
449 * @tc.desc: OnRemoteRequest func test
450 * @tc.type: FUNC
451 */
452 HWTEST_F(ScreenSessionAbilityConnectionUtTest, OnRemoteRequest, TestSize.Level1)
453 {
454 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
455 new (std::nothrow) ScreenSessionAbilityConnectionStub());
456 ASSERT_NE(abilityConnectionStub, nullptr);
457 AAFwk::Want want;
458 want.SetElementName("com.ohos.sceneboard",
459 "com.ohos.sceneboard.systemdialog");
460 std::string identity = IPCSkeleton::ResetCallingIdentity();
461 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
462 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
463 IPCSkeleton::SetCallingIdentity(identity);
464 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
465 ASSERT_EQ(resConnect, ERR_OK);
466 {
467 std::unique_lock<std::mutex> lock(connectedMutex_);
468 static_cast<void>(connectedCv_.wait_for(lock, std::chrono::milliseconds(EXTENSION_CONNECT_OUT_TIME)));
469 }
470 MessageParcel data;
471 MessageParcel reply;
472 MessageOption option;
473 data.WriteString16(Str8ToStr16("SA"));
474 data.WriteString16(Str8ToStr16("ScreenSessionManager"));
475 abilityConnectionStub->OnRemoteRequest(TRANS_CMD_SEND_SNAPSHOT_RECT, data, reply, option);
476 EXPECT_EQ(reply.ReadInt32(), 0);
477 EXPECT_EQ(reply.ReadInt32(), 0);
478 EXPECT_EQ(reply.ReadInt32(), 0);
479 EXPECT_EQ(reply.ReadInt32(), 0);
480 EXPECT_EQ(reply.ReadInt32(), 0);
481 auto resDisconnect = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
482 ASSERT_EQ(resDisconnect, NO_ERROR);
483 } else {
484 ASSERT_NE(resConnect, ERR_OK);
485 }
486 abilityConnectionStub.clear();
487 abilityConnectionStub = nullptr;
488 }
489
490 /**
491 * @tc.name: GetScreenId
492 * @tc.desc: GetScreenId func test
493 * @tc.type: FUNC
494 */
495 HWTEST_F(ScreenSessionAbilityConnectionUtTest, GetScreenId, TestSize.Level1)
496 {
497 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
498 new (std::nothrow) ScreenSessionAbilityConnectionStub());
499 ASSERT_NE(abilityConnectionStub, nullptr);
500 int32_t expection = 0;
501 EXPECT_EQ(abilityConnectionStub->GetScreenId(), expection);
502 abilityConnectionStub.clear();
503 abilityConnectionStub = nullptr;
504 }
505
506 /**
507 * @tc.name: GetLeft
508 * @tc.desc: GetLeft func test
509 * @tc.type: FUNC
510 */
511 HWTEST_F(ScreenSessionAbilityConnectionUtTest, GetLeft, TestSize.Level1)
512 {
513 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
514 new (std::nothrow) ScreenSessionAbilityConnectionStub());
515 ASSERT_NE(abilityConnectionStub, nullptr);
516 int32_t expection = 0;
517 EXPECT_EQ(abilityConnectionStub->GetLeft(), expection);
518 abilityConnectionStub.clear();
519 abilityConnectionStub = nullptr;
520 }
521
522 /**
523 * @tc.name: GetTop
524 * @tc.desc: GetTop func test
525 * @tc.type: FUNC
526 */
527 HWTEST_F(ScreenSessionAbilityConnectionUtTest, GetTop, TestSize.Level1)
528 {
529 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
530 new (std::nothrow) ScreenSessionAbilityConnectionStub());
531 ASSERT_NE(abilityConnectionStub, nullptr);
532 int32_t expection = 0;
533 EXPECT_EQ(abilityConnectionStub->GetTop(), expection);
534 abilityConnectionStub.clear();
535 abilityConnectionStub = nullptr;
536 }
537
538 /**
539 * @tc.name: GetWidth
540 * @tc.desc: GetWidth func test
541 * @tc.type: FUNC
542 */
543 HWTEST_F(ScreenSessionAbilityConnectionUtTest, GetWidth, TestSize.Level1)
544 {
545 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
546 new (std::nothrow) ScreenSessionAbilityConnectionStub());
547 ASSERT_NE(abilityConnectionStub, nullptr);
548 int32_t expection = 0;
549 EXPECT_EQ(abilityConnectionStub->GetWidth(), expection);
550 abilityConnectionStub.clear();
551 abilityConnectionStub = nullptr;
552 }
553
554 /**
555 * @tc.name: GetHeight
556 * @tc.desc: GetHeight func test
557 * @tc.type: FUNC
558 */
559 HWTEST_F(ScreenSessionAbilityConnectionUtTest, GetHeight, TestSize.Level1)
560 {
561 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
562 new (std::nothrow) ScreenSessionAbilityConnectionStub());
563 ASSERT_NE(abilityConnectionStub, nullptr);
564 int32_t expection = 0;
565 EXPECT_EQ(abilityConnectionStub->GetHeight(), expection);
566 abilityConnectionStub.clear();
567 abilityConnectionStub = nullptr;
568 }
569
570 /**
571 * @tc.name: GetErrCode
572 * @tc.desc: GetErrCode func test
573 * @tc.type: FUNC
574 */
575 HWTEST_F(ScreenSessionAbilityConnectionUtTest, GetErrCode, TestSize.Level1)
576 {
577 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
578 new (std::nothrow) ScreenSessionAbilityConnectionStub());
579 ASSERT_NE(abilityConnectionStub, nullptr);
580 uint32_t expection = 0;
581 EXPECT_EQ(abilityConnectionStub->GetErrCode(), expection);
582 abilityConnectionStub.clear();
583 abilityConnectionStub = nullptr;
584 }
585
586 /**
587 * @tc.name: EraseErrCode
588 * @tc.desc: EraseErrCode func test
589 * @tc.type: FUNC
590 */
591 HWTEST_F(ScreenSessionAbilityConnectionUtTest, EraseErrCode, TestSize.Level1)
592 {
593 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
594 new (std::nothrow) ScreenSessionAbilityConnectionStub());
595 ASSERT_NE(abilityConnectionStub, nullptr);
596 abilityConnectionStub->errCode_ = 1;
597 uint32_t expection = 0;
598 abilityConnectionStub->EraseErrCode();
599 EXPECT_EQ(abilityConnectionStub->errCode_, expection);
600 abilityConnectionStub.clear();
601 abilityConnectionStub = nullptr;
602 }
603 }
604 } // namespace Rosen
605 } // namespace OHOS