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 #include "iremote_object_mocker.h"
27 #include "window_manager_hilog.h"
28
29 using namespace testing;
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace Rosen {
34 namespace {
35 std::string g_errlog;
ScreenSessionLogCallback(const LogType type,const LogLevel level,const unsigned int domain,const char * tag,const char * msg)36 void ScreenSessionLogCallback(
37 const LogType type, const LogLevel level, const unsigned int domain, const char *tag, const char *msg)
38 {
39 g_errlog = msg;
40 }
41 } // namespace name
42
43 constexpr int32_t DEFAULT_VALUE = -1;
44 constexpr uint32_t EXTENSION_CONNECT_OUT_TIME = 300; // ms
45 constexpr uint32_t TRANS_CMD_SEND_SNAPSHOT_RECT = 2;
46 constexpr int32_t RES_FAILURE = -1;
47 constexpr int32_t RES_SUCCESS = -1;
48 namespace {
49 constexpr uint32_t SLEEP_TIME_US = 100000;
50 }
51
52 class ScreenSessionAbilityConnectionTest : public testing::Test {
53 public:
54 static void SetUpTestCase();
55 static void TearDownTestCase();
56 void SetUp() override;
57 void TearDown() override;
58 std::recursive_mutex mutex_;
59
60 private:
61 std::mutex connectedMutex_;
62 std::condition_variable connectedCv_;
63 };
64
SetUpTestCase()65 void ScreenSessionAbilityConnectionTest::SetUpTestCase()
66 {
67 }
68
TearDownTestCase()69 void ScreenSessionAbilityConnectionTest::TearDownTestCase()
70 {
71 }
72
SetUp()73 void ScreenSessionAbilityConnectionTest::SetUp()
74 {
75 }
76
TearDown()77 void ScreenSessionAbilityConnectionTest::TearDown()
78 {
79 usleep(SLEEP_TIME_US);
80 }
81
82 namespace {
83
84 /**
85 * @tc.name: OnAbilityConnectDone
86 * @tc.desc: OnAbilityConnectDone func test
87 * @tc.type: FUNC
88 */
89 HWTEST_F(ScreenSessionAbilityConnectionTest, OnAbilityConnectDone, TestSize.Level1)
90 {
91 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
92 new (std::nothrow) ScreenSessionAbilityConnectionStub());
93 ASSERT_NE(abilityConnectionStub, nullptr);
94 AAFwk::Want want;
95 want.SetElementName("com.ohos.sceneboard",
96 "com.ohos.sceneboard.systemdialog");
97 std::string identity = IPCSkeleton::ResetCallingIdentity();
98 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
99 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
100 IPCSkeleton::SetCallingIdentity(identity);
101 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
102 ASSERT_EQ(resConnect, ERR_OK);
103 {
104 std::unique_lock<std::mutex> lock(connectedMutex_);
105 static_cast<void>(connectedCv_.wait_for(lock, std::chrono::milliseconds(EXTENSION_CONNECT_OUT_TIME)));
106 }
107 auto resDisconnect = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
108 ASSERT_EQ(resDisconnect, NO_ERROR);
109 } else {
110 ASSERT_NE(resConnect, ERR_OK);
111 }
112 abilityConnectionStub.clear();
113 abilityConnectionStub = nullptr;
114 }
115
116 /**
117 * @tc.name: OnAbilityDisconnectDone
118 * @tc.desc: OnAbilityDisconnectDone func
119 * @tc.type: FUNC
120 */
121 HWTEST_F(ScreenSessionAbilityConnectionTest, OnAbilityDisconnectDone, TestSize.Level1)
122 {
123 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
124 new (std::nothrow) ScreenSessionAbilityConnectionStub());
125 ASSERT_NE(abilityConnectionStub, nullptr);
126 AAFwk::Want want;
127 want.SetElementName("com.ohos.sceneboard",
128 "com.ohos.sceneboard.systemdialog");
129 std::string identity = IPCSkeleton::ResetCallingIdentity();
130 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
131 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
132 IPCSkeleton::SetCallingIdentity(identity);
133 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
134 ASSERT_EQ(resConnect, ERR_OK);
135 AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
136 EXPECT_EQ(abilityConnectionStub->IsAbilityConnected(), false);
137 } else {
138 ASSERT_NE(resConnect, ERR_OK);
139 }
140 abilityConnectionStub.clear();
141 abilityConnectionStub = nullptr;
142 }
143
144 /**
145 * @tc.name: AddObjectDeathRecipient
146 * @tc.desc: AddObjectDeathRecipient func
147 * @tc.type: FUNC
148 */
149 HWTEST_F(ScreenSessionAbilityConnectionTest, AddObjectDeathRecipient, TestSize.Level1)
150 {
151 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
152 new (std::nothrow) ScreenSessionAbilityConnectionStub());
153 ASSERT_NE(abilityConnectionStub, nullptr);
154 EXPECT_EQ(abilityConnectionStub->AddObjectDeathRecipient(), false);
155 abilityConnectionStub.clear();
156 abilityConnectionStub = nullptr;
157 }
158
159 /**
160 * @tc.name: SendMessage
161 * @tc.desc: SendMessage func test02
162 * @tc.type: FUNC
163 */
164 HWTEST_F(ScreenSessionAbilityConnectionTest, SendMessage02, TestSize.Level1)
165 {
166 ScreenSessionAbilityConnection screenSessionAbilityConnection;
167 int32_t transCode = 0;
168 MessageParcel data;
169 MessageParcel reply;
170 auto ret = screenSessionAbilityConnection.SendMessage(transCode, data, reply);
171 EXPECT_EQ(ret, RES_FAILURE);
172 }
173
174 /**
175 * @tc.name: IsConnected
176 * @tc.desc: IsConnected func
177 * @tc.type: FUNC
178 */
179 HWTEST_F(ScreenSessionAbilityConnectionTest, IsConnected, TestSize.Level1)
180 {
181 ScreenSessionAbilityConnection screenSessionAbilityConnection;
182 auto ret = screenSessionAbilityConnection.IsConnected();
183 EXPECT_EQ(ret, false);
184 }
185
186 /**
187 * @tc.name: IsAbilityConnected
188 * @tc.desc: IsAbilityConnected func
189 * @tc.type: FUNC
190 */
191 HWTEST_F(ScreenSessionAbilityConnectionTest, IsAbilityConnected, TestSize.Level1)
192 {
193 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
194 new (std::nothrow) ScreenSessionAbilityConnectionStub());
195 ASSERT_NE(abilityConnectionStub, nullptr);
196 EXPECT_EQ(abilityConnectionStub->IsAbilityConnected(), false);
197 abilityConnectionStub.clear();
198 abilityConnectionStub = nullptr;
199 }
200
201 /**
202 * @tc.name: SendMessageSync
203 * @tc.desc: SendMessageSync func
204 * @tc.type: FUNC
205 */
206 HWTEST_F(ScreenSessionAbilityConnectionTest, SendMessageSync, TestSize.Level1)
207 {
208 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
209 new (std::nothrow) ScreenSessionAbilityConnectionStub());
210 ASSERT_NE(abilityConnectionStub, nullptr);
211 AAFwk::Want want;
212 want.SetElementName("com.ohos.sceneboard",
213 "com.ohos.sceneboard.systemdialog");
214 std::string identity = IPCSkeleton::ResetCallingIdentity();
215 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
216 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
217 IPCSkeleton::SetCallingIdentity(identity);
218 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
219 ASSERT_EQ(resConnect, ERR_OK);
220 {
221 std::unique_lock<std::mutex> lock(connectedMutex_);
222 static_cast<void>(connectedCv_.wait_for(lock, std::chrono::milliseconds(EXTENSION_CONNECT_OUT_TIME)));
223 }
224 MessageParcel data;
225 MessageParcel reply;
226 data.WriteString16(Str8ToStr16("SA"));
227 data.WriteString16(Str8ToStr16("ScreenSessionManager"));
228 abilityConnectionStub->SendMessageSync(TRANS_CMD_SEND_SNAPSHOT_RECT, data, reply);
229 EXPECT_EQ(reply.ReadInt32(), 0);
230 EXPECT_EQ(reply.ReadInt32(), 0);
231 EXPECT_EQ(reply.ReadInt32(), 0);
232 EXPECT_EQ(reply.ReadInt32(), 0);
233 EXPECT_EQ(reply.ReadInt32(), 0);
234 auto resDisconnect = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
235 ASSERT_EQ(resDisconnect, NO_ERROR);
236 } else {
237 ASSERT_NE(resConnect, ERR_OK);
238 }
239 abilityConnectionStub.clear();
240 abilityConnectionStub = nullptr;
241 }
242
243 /**
244 * @tc.name: OnRemoteDied
245 * @tc.desc: OnRemoteDied func
246 * @tc.type: FUNC
247 */
248 HWTEST_F(ScreenSessionAbilityConnectionTest, OnRemoteDied, TestSize.Level1)
249 {
250 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
251 new (std::nothrow) ScreenSessionAbilityConnectionStub());
252 ASSERT_NE(abilityConnectionStub, nullptr);
253 AAFwk::Want want;
254 want.SetElementName("com.ohos.sceneboard",
255 "com.ohos.sceneboard.systemdialog");
256 std::string identity = IPCSkeleton::ResetCallingIdentity();
257 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
258 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
259 IPCSkeleton::SetCallingIdentity(identity);
260 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
261 ASSERT_EQ(resConnect, ERR_OK);
262 AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
263 EXPECT_EQ(abilityConnectionStub->IsAbilityConnected(), false);
264 } else {
265 ASSERT_NE(resConnect, ERR_OK);
266 }
267 abilityConnectionStub.clear();
268 abilityConnectionStub = nullptr;
269 }
270
271 /**
272 * @tc.name: IsAbilityConnectedSync
273 * @tc.desc: IsAbilityConnectedSync func
274 * @tc.type: FUNC
275 */
276 HWTEST_F(ScreenSessionAbilityConnectionTest, IsAbilityConnectedSync, TestSize.Level1)
277 {
278 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
279 new (std::nothrow) ScreenSessionAbilityConnectionStub());
280 ASSERT_NE(abilityConnectionStub, nullptr);
281 EXPECT_EQ(abilityConnectionStub->IsAbilityConnectedSync(), false);
282 abilityConnectionStub.clear();
283 abilityConnectionStub = nullptr;
284 }
285
286 /**
287 * @tc.name: ScreenSessionConnectExtension
288 * @tc.desc: ScreenSessionConnectExtension func
289 * @tc.type: FUNC
290 */
291 HWTEST_F(ScreenSessionAbilityConnectionTest, ScreenSessionConnectExtension, TestSize.Level1)
292 {
293 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
294 new (std::nothrow) ScreenSessionAbilityConnectionStub());
295 ASSERT_NE(abilityConnectionStub, nullptr);
296 AAFwk::Want want;
297 const std::string bundleName = "com.ohos.sceneboard";
298 const std::string abilityName = "com.ohos.sceneboard.systemdialog";
299 want.SetElementName(bundleName, abilityName);
300 std::string identity = IPCSkeleton::ResetCallingIdentity();
301 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
302 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
303 IPCSkeleton::SetCallingIdentity(identity);
304 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
305 ASSERT_EQ(resConnect, ERR_OK);
306 } else {
307 ASSERT_NE(resConnect, ERR_OK);
308 }
309 abilityConnectionStub.clear();
310 abilityConnectionStub = nullptr;
311 }
312
313 /**
314 * @tc.name: ScreenSessionConnectExtension02
315 * @tc.desc: ScreenSessionConnectExtension02 func
316 * @tc.type: FUNC
317 */
318 HWTEST_F(ScreenSessionAbilityConnectionTest, ScreenSessionConnectExtension02, TestSize.Level1)
319 {
320 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
321 new (std::nothrow) ScreenSessionAbilityConnectionStub());
322 ASSERT_NE(abilityConnectionStub, nullptr);
323 AAFwk::Want want;
324 const std::string bundleName = "com.ohos.sceneboard";
325 const std::string abilityName = "com.ohos.sceneboard.systemdialog";
326 want.SetElementName(bundleName, abilityName);
327 std::string paramKey = "requestReason";
328 std::string paramValue = "onPlugIn";
329 want.SetParam(paramKey, paramValue);
330 std::string identity = IPCSkeleton::ResetCallingIdentity();
331 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
332 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
333 IPCSkeleton::SetCallingIdentity(identity);
334 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
335 ASSERT_EQ(resConnect, ERR_OK);
336 } else {
337 ASSERT_NE(resConnect, ERR_OK);
338 }
339 abilityConnectionStub.clear();
340 abilityConnectionStub = nullptr;
341 }
342
343 /**
344 * @tc.name: ScreenSessionDisconnectExtension
345 * @tc.desc: ScreenSessionDisconnectExtension func test
346 * @tc.type: FUNC
347 */
348 HWTEST_F(ScreenSessionAbilityConnectionTest, ScreenSessionDisconnectExtension, TestSize.Level1)
349 {
350 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
351 new (std::nothrow) ScreenSessionAbilityConnectionStub());
352 ASSERT_NE(abilityConnectionStub, nullptr);
353 AAFwk::Want want;
354 want.SetElementName("com.ohos.sceneboard",
355 "com.ohos.sceneboard.systemdialog");
356 std::string identity = IPCSkeleton::ResetCallingIdentity();
357 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
358 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
359 IPCSkeleton::SetCallingIdentity(identity);
360 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
361 ASSERT_EQ(resConnect, ERR_OK);
362 {
363 std::unique_lock<std::mutex> lock(connectedMutex_);
364 static_cast<void>(connectedCv_.wait_for(lock, std::chrono::milliseconds(EXTENSION_CONNECT_OUT_TIME)));
365 }
366 auto resDisconnect = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
367 ASSERT_EQ(resDisconnect, NO_ERROR);
368 } else {
369 ASSERT_NE(resConnect, ERR_OK);
370 }
371 abilityConnectionStub.clear();
372 abilityConnectionStub = nullptr;
373 }
374
375 /**
376 * @tc.name: SendMessage
377 * @tc.desc: SendMessage func test
378 * @tc.type: FUNC
379 */
380 HWTEST_F(ScreenSessionAbilityConnectionTest, SendMessage, TestSize.Level1)
381 {
382 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
383 new (std::nothrow) ScreenSessionAbilityConnectionStub());
384 ASSERT_NE(abilityConnectionStub, nullptr);
385 AAFwk::Want want;
386 want.SetElementName("com.ohos.sceneboard",
387 "com.ohos.sceneboard.systemdialog");
388 std::string identity = IPCSkeleton::ResetCallingIdentity();
389 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
390 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
391 IPCSkeleton::SetCallingIdentity(identity);
392 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
393 ASSERT_EQ(resConnect, ERR_OK);
394 {
395 std::unique_lock<std::mutex> lock(connectedMutex_);
396 static_cast<void>(connectedCv_.wait_for(lock, std::chrono::milliseconds(EXTENSION_CONNECT_OUT_TIME)));
397 }
398 MessageParcel data;
399 MessageParcel reply;
400 data.WriteString16(Str8ToStr16("SA"));
401 data.WriteString16(Str8ToStr16("ScreenSessionManager"));
402 abilityConnectionStub->SendMessageSync(TRANS_CMD_SEND_SNAPSHOT_RECT, data, reply);
403 EXPECT_EQ(reply.ReadInt32(), 0);
404 EXPECT_EQ(reply.ReadInt32(), 0);
405 EXPECT_EQ(reply.ReadInt32(), 0);
406 EXPECT_EQ(reply.ReadInt32(), 0);
407 EXPECT_EQ(reply.ReadInt32(), 0);
408 auto resDisconnect = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
409 ASSERT_EQ(resDisconnect, NO_ERROR);
410 } else {
411 ASSERT_NE(resConnect, ERR_OK);
412 }
413 abilityConnectionStub.clear();
414 abilityConnectionStub = nullptr;
415 }
416
417 /**
418 * @tc.name: SendMessageBlock
419 * @tc.desc: SendMessageBlock func test
420 * @tc.type: FUNC
421 */
422 HWTEST_F(ScreenSessionAbilityConnectionTest, SendMessageBlock, TestSize.Level1)
423 {
424 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
425 new (std::nothrow) ScreenSessionAbilityConnectionStub());
426 ASSERT_NE(abilityConnectionStub, nullptr);
427 AAFwk::Want want;
428 want.SetElementName("com.ohos.sceneboard",
429 "com.ohos.sceneboard.systemdialog");
430 std::string identity = IPCSkeleton::ResetCallingIdentity();
431 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
432 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
433 IPCSkeleton::SetCallingIdentity(identity);
434 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
435 ASSERT_EQ(resConnect, ERR_OK);
436 {
437 std::unique_lock<std::mutex> lock(connectedMutex_);
438 static_cast<void>(connectedCv_.wait_for(lock, std::chrono::milliseconds(EXTENSION_CONNECT_OUT_TIME)));
439 }
440 MessageParcel data;
441 MessageParcel reply;
442 data.WriteString16(Str8ToStr16("SA"));
443 data.WriteString16(Str8ToStr16("ScreenSessionManager"));
444 abilityConnectionStub->SendMessageSyncBlock(TRANS_CMD_SEND_SNAPSHOT_RECT, data, reply);
445 EXPECT_EQ(reply.ReadInt32(), 0);
446 EXPECT_EQ(reply.ReadInt32(), 0);
447 EXPECT_EQ(reply.ReadInt32(), 0);
448 EXPECT_EQ(reply.ReadInt32(), 0);
449 EXPECT_EQ(reply.ReadInt32(), 0);
450 auto resDisconnect = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
451 ASSERT_EQ(resDisconnect, NO_ERROR);
452 } else {
453 ASSERT_NE(resConnect, ERR_OK);
454 }
455 abilityConnectionStub.clear();
456 abilityConnectionStub = nullptr;
457 }
458
459 /**
460 * @tc.name: OnRemoteRequest
461 * @tc.desc: OnRemoteRequest func test
462 * @tc.type: FUNC
463 */
464 HWTEST_F(ScreenSessionAbilityConnectionTest, OnRemoteRequest, TestSize.Level1)
465 {
466 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
467 new (std::nothrow) ScreenSessionAbilityConnectionStub());
468 ASSERT_NE(abilityConnectionStub, nullptr);
469 AAFwk::Want want;
470 want.SetElementName("com.ohos.sceneboard",
471 "com.ohos.sceneboard.systemdialog");
472 std::string identity = IPCSkeleton::ResetCallingIdentity();
473 auto resConnect = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(
474 want, abilityConnectionStub, nullptr, DEFAULT_VALUE);
475 IPCSkeleton::SetCallingIdentity(identity);
476 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
477 ASSERT_EQ(resConnect, ERR_OK);
478 {
479 std::unique_lock<std::mutex> lock(connectedMutex_);
480 static_cast<void>(connectedCv_.wait_for(lock, std::chrono::milliseconds(EXTENSION_CONNECT_OUT_TIME)));
481 }
482 MessageParcel data;
483 MessageParcel reply;
484 MessageOption option;
485 data.WriteString16(Str8ToStr16("SA"));
486 data.WriteString16(Str8ToStr16("ScreenSessionManager"));
487 abilityConnectionStub->OnRemoteRequest(TRANS_CMD_SEND_SNAPSHOT_RECT, data, reply, option);
488 EXPECT_EQ(reply.ReadInt32(), 0);
489 EXPECT_EQ(reply.ReadInt32(), 0);
490 EXPECT_EQ(reply.ReadInt32(), 0);
491 EXPECT_EQ(reply.ReadInt32(), 0);
492 EXPECT_EQ(reply.ReadInt32(), 0);
493 auto resDisconnect = AAFwk::ExtensionManagerClient::GetInstance().DisconnectAbility(abilityConnectionStub);
494 ASSERT_EQ(resDisconnect, NO_ERROR);
495 } else {
496 ASSERT_NE(resConnect, ERR_OK);
497 }
498 abilityConnectionStub.clear();
499 abilityConnectionStub = nullptr;
500 }
501
502 /**
503 * @tc.name: GetScreenId
504 * @tc.desc: GetScreenId func test
505 * @tc.type: FUNC
506 */
507 HWTEST_F(ScreenSessionAbilityConnectionTest, GetScreenId, TestSize.Level1)
508 {
509 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
510 new (std::nothrow) ScreenSessionAbilityConnectionStub());
511 ASSERT_NE(abilityConnectionStub, nullptr);
512 int32_t expection = 0;
513 EXPECT_EQ(abilityConnectionStub->GetScreenId(), expection);
514 abilityConnectionStub.clear();
515 abilityConnectionStub = nullptr;
516 }
517
518 /**
519 * @tc.name: GetLeft
520 * @tc.desc: GetLeft func test
521 * @tc.type: FUNC
522 */
523 HWTEST_F(ScreenSessionAbilityConnectionTest, GetLeft, TestSize.Level1)
524 {
525 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
526 new (std::nothrow) ScreenSessionAbilityConnectionStub());
527 ASSERT_NE(abilityConnectionStub, nullptr);
528 int32_t expection = 0;
529 EXPECT_EQ(abilityConnectionStub->GetLeft(), expection);
530 abilityConnectionStub.clear();
531 abilityConnectionStub = nullptr;
532 }
533
534 /**
535 * @tc.name: GetTop
536 * @tc.desc: GetTop func test
537 * @tc.type: FUNC
538 */
539 HWTEST_F(ScreenSessionAbilityConnectionTest, GetTop, TestSize.Level1)
540 {
541 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
542 new (std::nothrow) ScreenSessionAbilityConnectionStub());
543 ASSERT_NE(abilityConnectionStub, nullptr);
544 int32_t expection = 0;
545 EXPECT_EQ(abilityConnectionStub->GetTop(), expection);
546 abilityConnectionStub.clear();
547 abilityConnectionStub = nullptr;
548 }
549
550 /**
551 * @tc.name: GetWidth
552 * @tc.desc: GetWidth func test
553 * @tc.type: FUNC
554 */
555 HWTEST_F(ScreenSessionAbilityConnectionTest, GetWidth, TestSize.Level1)
556 {
557 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
558 new (std::nothrow) ScreenSessionAbilityConnectionStub());
559 ASSERT_NE(abilityConnectionStub, nullptr);
560 int32_t expection = 0;
561 EXPECT_EQ(abilityConnectionStub->GetWidth(), expection);
562 abilityConnectionStub.clear();
563 abilityConnectionStub = nullptr;
564 }
565
566 /**
567 * @tc.name: GetHeight
568 * @tc.desc: GetHeight func test
569 * @tc.type: FUNC
570 */
571 HWTEST_F(ScreenSessionAbilityConnectionTest, GetHeight, TestSize.Level1)
572 {
573 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
574 new (std::nothrow) ScreenSessionAbilityConnectionStub());
575 ASSERT_NE(abilityConnectionStub, nullptr);
576 int32_t expection = 0;
577 EXPECT_EQ(abilityConnectionStub->GetHeight(), expection);
578 abilityConnectionStub.clear();
579 abilityConnectionStub = nullptr;
580 }
581
582 /**
583 * @tc.name: GetErrCode
584 * @tc.desc: GetErrCode func test
585 * @tc.type: FUNC
586 */
587 HWTEST_F(ScreenSessionAbilityConnectionTest, GetErrCode, TestSize.Level1)
588 {
589 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
590 new (std::nothrow) ScreenSessionAbilityConnectionStub());
591 ASSERT_NE(abilityConnectionStub, nullptr);
592 uint32_t expection = 0;
593 EXPECT_EQ(abilityConnectionStub->GetErrCode(), expection);
594 abilityConnectionStub.clear();
595 abilityConnectionStub = nullptr;
596 }
597
598 /**
599 * @tc.name: EraseErrCode
600 * @tc.desc: EraseErrCode func test
601 * @tc.type: FUNC
602 */
603 HWTEST_F(ScreenSessionAbilityConnectionTest, EraseErrCode, TestSize.Level1)
604 {
605 sptr<ScreenSessionAbilityConnectionStub> abilityConnectionStub(
606 new (std::nothrow) ScreenSessionAbilityConnectionStub());
607 ASSERT_NE(abilityConnectionStub, nullptr);
608 abilityConnectionStub->errCode_ = 1;
609 uint32_t expection = 0;
610 abilityConnectionStub->EraseErrCode();
611 EXPECT_EQ(abilityConnectionStub->errCode_, expection);
612 abilityConnectionStub.clear();
613 abilityConnectionStub = nullptr;
614 }
615
616 /**
617 * @tc.name: OnAbilityConnectDone01
618 * @tc.desc: EraseErrCode func test
619 * @tc.type: FUNC
620 */
621 HWTEST_F(ScreenSessionAbilityConnectionTest, OnAbilityConnectDone01, TestSize.Level1)
622 {
623 LOG_SetCallback(ScreenSessionLogCallback);
624 auto abilityConnectionStub = sptr<ScreenSessionAbilityConnectionStub>::MakeSptr();
625 AppExecFwk::ElementName element;
626 sptr<IRemoteObject> remoteObject = nullptr;
627 int32_t resultCode = 1;
628 abilityConnectionStub->OnAbilityConnectDone(element, remoteObject, resultCode);
629
630 resultCode = 0;
631 abilityConnectionStub->OnAbilityConnectDone(element, remoteObject, resultCode);
632 remoteObject = sptr<MockIRemoteObject>::MakeSptr();
633 auto ret = abilityConnectionStub->AddObjectDeathRecipient();
634 EXPECT_EQ(ret, false);
635 abilityConnectionStub->OnAbilityConnectDone(element, remoteObject, resultCode);
636 EXPECT_TRUE(g_errlog.find("OnAbilityConnectDone exit") != std::string::npos);
637 }
638
639 /**
640 * @tc.name: OnAbilityDisconnectDone01
641 * @tc.desc: EraseErrCode func test
642 * @tc.type: FUNC
643 */
644 HWTEST_F(ScreenSessionAbilityConnectionTest, OnAbilityDisconnectDone01, TestSize.Level1)
645 {
646 LOG_SetCallback(ScreenSessionLogCallback);
647 auto abilityConnectionStub = sptr<ScreenSessionAbilityConnectionStub>::MakeSptr();
648 AppExecFwk::ElementName element;
649 int32_t resultCode = 0;
650 abilityConnectionStub->remoteObject_ = nullptr;
651 abilityConnectionStub->OnAbilityDisconnectDone(element, resultCode);
652
653 resultCode = 1;
654 abilityConnectionStub->remoteObject_ = sptr<MockIRemoteObject>::MakeSptr();
655 abilityConnectionStub->OnAbilityDisconnectDone(element, resultCode);
656 EXPECT_TRUE(g_errlog.find("OnAbilityDisconnectDone exit") != std::string::npos);
657 }
658
659 /**
660 * @tc.name: AddObjectDeathRecipient01
661 * @tc.desc: EraseErrCode func test
662 * @tc.type: FUNC
663 */
664 HWTEST_F(ScreenSessionAbilityConnectionTest, AddObjectDeathRecipient01, TestSize.Level1)
665 {
666 auto abilityConnectionStub = sptr<ScreenSessionAbilityConnectionStub>::MakeSptr();
667 auto ret = abilityConnectionStub->AddObjectDeathRecipient();
668 EXPECT_EQ(ret, false);
669
670 abilityConnectionStub->remoteObject_ = nullptr;
671 ret = abilityConnectionStub->AddObjectDeathRecipient();
672 EXPECT_TRUE(g_errlog.find("remoteObject") != std::string::npos);
673 EXPECT_EQ(ret, false);
674 abilityConnectionStub->remoteObject_ = sptr<MockIRemoteObject>::MakeSptr();
675 abilityConnectionStub->AddObjectDeathRecipient();
676 EXPECT_FALSE(g_errlog.find("AddDeathRecipient") != std::string::npos);
677 }
678
679 /**
680 * @tc.name: IsConnected01
681 * @tc.desc: EraseErrCode func test
682 * @tc.type: FUNC
683 */
684 HWTEST_F(ScreenSessionAbilityConnectionTest, IsConnected01, TestSize.Level1)
685 {
686 ScreenSessionAbilityConnection abilityConnection;
687 abilityConnection.abilityConnectionStub_ = nullptr;
688 auto ret = abilityConnection.IsConnected();
689 EXPECT_EQ(ret, false);
690
691 abilityConnection.abilityConnectionStub_ = sptr<ScreenSessionAbilityConnectionStub>::MakeSptr();
692 abilityConnection.IsConnected();
693 EXPECT_EQ(ret, false);
694 }
695
696 /**
697 * @tc.name: SendMessageBlock01
698 * @tc.desc: EraseErrCode func test
699 * @tc.type: FUNC
700 */
701 HWTEST_F(ScreenSessionAbilityConnectionTest, SendMessageBlock01, TestSize.Level1)
702 {
703 int32_t transCode = 0;
704 MessageParcel data;
705 MessageParcel reply;
706 ScreenSessionAbilityConnection abilityConnection;
707 abilityConnection.abilityConnectionStub_ = nullptr;
708 auto ret = abilityConnection.SendMessageBlock(transCode, data, reply);
709 EXPECT_EQ(ret, RES_FAILURE);
710
711 abilityConnection.abilityConnectionStub_ = sptr<ScreenSessionAbilityConnectionStub>::MakeSptr();
712 ret = abilityConnection.SendMessageBlock(transCode, data, reply);
713 EXPECT_EQ(ret, RES_SUCCESS);
714 }
715
716 /**
717 * @tc.name: SendMessage01
718 * @tc.desc: EraseErrCode func test
719 * @tc.type: FUNC
720 */
721 HWTEST_F(ScreenSessionAbilityConnectionTest, SendMessage01, TestSize.Level1)
722 {
723 int32_t transCode = 0;
724 MessageParcel data;
725 MessageParcel reply;
726 ScreenSessionAbilityConnection abilityConnection;
727 abilityConnection.abilityConnectionStub_ = nullptr;
728 auto ret = abilityConnection.SendMessage(transCode, data, reply);
729 EXPECT_EQ(ret, RES_FAILURE);
730
731 abilityConnection.abilityConnectionStub_ = sptr<ScreenSessionAbilityConnectionStub>::MakeSptr();
732 ret = abilityConnection.SendMessageBlock(transCode, data, reply);
733 EXPECT_EQ(ret, RES_SUCCESS);
734 }
735
736 /**
737 * @tc.name: OnRemoteDied01
738 * @tc.desc: EraseErrCode func test
739 * @tc.type: FUNC
740 */
741 HWTEST_F(ScreenSessionAbilityConnectionTest, OnRemoteDied01, TestSize.Level1)
742 {
743 wptr<IRemoteObject> remoteObject = nullptr;
744 std::function<void(void)> deathHandler;
745 ScreenSessionAbilityDeathRecipient abilityDeathRecipient(deathHandler);
746 abilityDeathRecipient.OnRemoteDied(remoteObject);
747 EXPECT_TRUE(g_errlog.find("remoteObject is null") != std::string::npos);
748
749 remoteObject = sptr<MockIRemoteObject>::MakeSptr();
__anonb02d31bd0402() 750 abilityDeathRecipient.deathHandler_ = []() { std::cout << "Death handler called" << std::endl; };
751 EXPECT_NE(abilityDeathRecipient.deathHandler_, nullptr);
752 abilityDeathRecipient.OnRemoteDied(remoteObject);
753 }
754 } // namespace
755 } // namespace Rosen
756 } // namespace OHOS