1 /*
2 * Copyright (c) 2022-2025 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 #define private public
19 #include "ability_manager_client.h"
20 #include "service_extension_context.h"
21 #undef private
22
23 #include "ability_connection.h"
24 #include "ability_manager_stub_mock.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::AppExecFwk;
28
29 namespace OHOS {
30 namespace AbilityRuntime {
31 class ServiceExtensionContextTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37 };
38
SetUpTestCase(void)39 void ServiceExtensionContextTest::SetUpTestCase(void)
40 {}
TearDownTestCase(void)41 void ServiceExtensionContextTest::TearDownTestCase(void)
42 {}
SetUp(void)43 void ServiceExtensionContextTest::SetUp(void)
44 {}
TearDown(void)45 void ServiceExtensionContextTest::TearDown(void)
46 {}
47
48 /*
49 * Feature: ServiceExtensionContext
50 * Function: startAbility
51 * SubFunction: NA
52 * FunctionPoints: ServiceExtensionContextTest startAbility
53 * EnvConditions: NA
54 * CaseDescription: Verify startAbility
55 */
56 HWTEST_F(ServiceExtensionContextTest, service_extension_context_startAbility_001, TestSize.Level1)
57 {
58 ServiceExtensionContext serviceExtensionContextTest;
59 Want want;
60 ErrCode result = serviceExtensionContextTest.StartAbility(want);
61 EXPECT_NE(ERR_OK, result);
62 }
63
64 /*
65 * Feature: ServiceExtensionContext
66 * Function: startAbility
67 * SubFunction: NA
68 * FunctionPoints: ServiceExtensionContextTest startAbility
69 * EnvConditions: NA
70 * CaseDescription: Verify startAbility
71 */
72 HWTEST_F(ServiceExtensionContextTest, service_extension_context_startAbility_002, TestSize.Level1)
73 {
74 ServiceExtensionContext serviceExtensionContextTest;
75 Want want;
76 StartOptions startOptions;
77 ErrCode result = serviceExtensionContextTest.StartAbility(want, startOptions);
78 EXPECT_NE(ERR_OK, result);
79 }
80
81 /*
82 * Feature: ServiceExtensionContext
83 * Function: startAbility
84 * SubFunction: NA
85 * FunctionPoints: ServiceExtensionContextTest StartAbilityAsCaller
86 * EnvConditions: NA
87 * CaseDescription: Verify startAbility
88 */
89 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartAbilityAsCaller_001, TestSize.Level1)
90 {
91 ServiceExtensionContext serviceExtensionContextTest;
92 Want want;
93 ErrCode result = serviceExtensionContextTest.StartAbilityAsCaller(want);
94 GTEST_LOG_(INFO) << result;
95 EXPECT_NE(ERR_OK, result);
96 }
97
98 /*
99 * Feature: ServiceExtensionContext
100 * Function: startAbility
101 * SubFunction: NA
102 * FunctionPoints: ServiceExtensionContextTest StartAbilityAsCaller
103 * EnvConditions: NA
104 * CaseDescription: Verify startAbility
105 */
106 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartAbilityAsCaller_002, TestSize.Level1)
107 {
108 ServiceExtensionContext serviceExtensionContextTest;
109 Want want;
110 StartOptions startOptions;
111 ErrCode result = serviceExtensionContextTest.StartAbilityAsCaller(want, startOptions);
112 GTEST_LOG_(INFO) << result;
113 EXPECT_NE(ERR_OK, result);
114 }
115
116 /*
117 * Feature: ServiceExtensionContext
118 * Function: startAbility
119 * SubFunction: NA
120 * FunctionPoints: ServiceExtensionContextTest startAbility
121 * EnvConditions: NA
122 * CaseDescription: Verify startAbility
123 */
124 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartAbilityByCall_001, TestSize.Level1)
125 {
126 ServiceExtensionContext serviceExtensionContextTest;
127 Want want;
128 std::shared_ptr<CallerCallBack> callback = std::make_shared<CallerCallBack>();
129 ErrCode result = serviceExtensionContextTest.StartAbilityByCall(want, callback);
130 EXPECT_EQ(ERR_INVALID_VALUE, result);
131 }
132
133 /*
134 * Feature: ServiceExtensionContext
135 * Function: startAbility
136 * SubFunction: NA
137 * FunctionPoints: ServiceExtensionContextTest startAbility
138 * EnvConditions: NA
139 * CaseDescription: Verify startAbility
140 */
141 HWTEST_F(ServiceExtensionContextTest, service_extension_context_ReleaseCall_001, TestSize.Level1)
142 {
143 ServiceExtensionContext serviceExtensionContextTest;
144 std::shared_ptr<CallerCallBack> callback = std::make_shared<CallerCallBack>();
145 ErrCode result = serviceExtensionContextTest.ReleaseCall(callback);
146 EXPECT_EQ(ERR_INVALID_VALUE, result);
147 }
148
149 /*
150 * Feature: ServiceExtensionContext
151 * Function: startAbility
152 * SubFunction: NA
153 * FunctionPoints: ServiceExtensionContextTest startAbility
154 * EnvConditions: NA
155 * CaseDescription: Verify startAbility
156 */
157 HWTEST_F(ServiceExtensionContextTest, service_extension_context_ConnectAbility_001, TestSize.Level1)
158 {
159 ServiceExtensionContext serviceExtensionContextTest;
160 Want want;
161 sptr<AbilityConnectCallback> connectCallback;
162 ErrCode result = serviceExtensionContextTest.ConnectAbility(want, connectCallback);
163 EXPECT_EQ(AAFwk::ERR_INVALID_CALLER, result);
164 }
165
166 /*
167 * Feature: ServiceExtensionContext
168 * Function: startAbility
169 * SubFunction: NA
170 * FunctionPoints: ServiceExtensionContextTest startAbility
171 * EnvConditions: NA
172 * CaseDescription: Verify startAbility
173 */
174 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartAbilityWithAccount_001, TestSize.Level1)
175 {
176 ServiceExtensionContext serviceExtensionContextTest;
177 Want want;
178 int accountId = 1;
179 ErrCode result = serviceExtensionContextTest.StartAbilityWithAccount(want, accountId);
180 EXPECT_EQ(CHECK_PERMISSION_FAILED, result);
181 }
182
183 /*
184 * Feature: ServiceExtensionContext
185 * Function: startAbility
186 * SubFunction: NA
187 * FunctionPoints: ServiceExtensionContextTest startAbility
188 * EnvConditions: NA
189 * CaseDescription: Verify startAbility
190 */
191 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartAbilityWithAccount_002, TestSize.Level1)
192 {
193 ServiceExtensionContext serviceExtensionContextTest;
194 Want want;
195 int accountId = 1;
196 StartOptions startOptions;
197 ErrCode result = serviceExtensionContextTest.StartAbilityWithAccount(want, accountId, startOptions);
198 EXPECT_EQ(CHECK_PERMISSION_FAILED, result);
199 }
200
201 /*
202 * Feature: ServiceExtensionContext
203 * Function: startAbility
204 * SubFunction: NA
205 * FunctionPoints: ServiceExtensionContextTest StartUIAbilities
206 * EnvConditions: NA
207 * CaseDescription: Verify StartUIAbilities
208 */
209 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartUIAbilities_001, TestSize.Level1)
210 {
211 ServiceExtensionContext serviceExtensionContextTest;
212 std::vector<AAFwk::Want> wantList(5);
213 std::string requestKey = "123";
214 ErrCode result = serviceExtensionContextTest.StartUIAbilities(wantList, requestKey);
215 EXPECT_NE(result, ERR_OK);
216 }
217
218 /*
219 * Feature: ServiceExtensionContext
220 * Function: startAbility
221 * SubFunction: NA
222 * FunctionPoints: ServiceExtensionContextTest StartServiceExtensionAbility
223 * EnvConditions: NA
224 * CaseDescription: Verify startAbility
225 */
226 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartServiceExtensionAbility_001, TestSize.Level1)
227 {
228 ServiceExtensionContext serviceExtensionContextTest;
229 Want want;
230 int32_t accountId = 1;
231 StartOptions startOptions;
232 ErrCode result = serviceExtensionContextTest.StartServiceExtensionAbility(want, accountId);
233 EXPECT_EQ(CHECK_PERMISSION_FAILED, result);
234 }
235
236 /*
237 * Feature: ServiceExtensionContext
238 * Function: startAbility
239 * SubFunction: NA
240 * FunctionPoints: ServiceExtensionContextTest StopServiceExtensionAbility
241 * EnvConditions: NA
242 * CaseDescription: Verify startAbility
243 */
244 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StopServiceExtensionAbility_001, TestSize.Level1)
245 {
246 ServiceExtensionContext serviceExtensionContextTest;
247 Want want;
248 int32_t accountId = 1;
249 StartOptions startOptions;
250 ErrCode result = serviceExtensionContextTest.StopServiceExtensionAbility(want, accountId);
251 EXPECT_EQ(CHECK_PERMISSION_FAILED, result);
252 }
253
254 /*
255 * Feature: ServiceExtensionContext
256 * Function: startAbility
257 * SubFunction: NA
258 * FunctionPoints: ServiceExtensionContextTest ConnectAbilityWithAccount
259 * EnvConditions: NA
260 * CaseDescription: Verify startAbility
261 */
262 HWTEST_F(ServiceExtensionContextTest, service_extension_context_ConnectAbilityWithAccount_001, TestSize.Level1)
263 {
264 ServiceExtensionContext serviceExtensionContextTest;
265 Want want;
266 int32_t accountId = 1;
267 sptr<AbilityConnectCallback> connectCallback;
268 ErrCode result = serviceExtensionContextTest.ConnectAbilityWithAccount(want, accountId, connectCallback);
269 EXPECT_EQ(AAFwk::ERR_INVALID_CALLER, result);
270 }
271
272 /*
273 * Feature: ServiceExtensionContext
274 * Function: startAbility
275 * SubFunction: NA
276 * FunctionPoints: ServiceExtensionContextTest ConnectAbilityWithAccount
277 * EnvConditions: NA
278 * CaseDescription: Verify startAbility
279 */
280 HWTEST_F(ServiceExtensionContextTest, service_extension_context_DisconnectAbility_001, TestSize.Level1)
281 {
282 ServiceExtensionContext serviceExtensionContextTest;
283 Want want;
284 int32_t accountId = 1;
285 sptr<AbilityConnectCallback> connectCallback;
286 ErrCode result = serviceExtensionContextTest.DisconnectAbility(want, connectCallback, accountId);
287 GTEST_LOG_(INFO) <<result;
288 EXPECT_EQ(AAFwk::ERR_INVALID_CALLER, result);
289 }
290
291 /*
292 * Feature: ServiceExtensionContext
293 * Function: startAbility
294 * SubFunction: NA
295 * FunctionPoints: ServiceExtensionContextTest TerminateAbility
296 * EnvConditions: NA
297 * CaseDescription: Verify startAbility
298 */
299 HWTEST_F(ServiceExtensionContextTest, service_extension_context_TerminateAbility_001, TestSize.Level1)
300 {
301 ServiceExtensionContext serviceExtensionContextTest;
302 ErrCode result = serviceExtensionContextTest.TerminateAbility();
303 EXPECT_EQ(ERR_INVALID_VALUE, result);
304 }
305
306 /*
307 * Feature: ServiceExtensionContext
308 * Function: startAbility
309 * SubFunction: NA
310 * FunctionPoints: ServiceExtensionContextTest RequestModalUIExtension
311 * EnvConditions: NA
312 * CaseDescription: Verify startAbility
313 */
314 HWTEST_F(ServiceExtensionContextTest, service_extension_context_RequestModalUIExtension_001, TestSize.Level1)
315 {
316 ServiceExtensionContext serviceExtensionContextTest;
317 Want want;
318 ErrCode result = serviceExtensionContextTest.RequestModalUIExtension(want);
319 EXPECT_EQ(serviceExtensionContextTest.localCallContainer_, nullptr);
320 GTEST_LOG_(INFO) <<result;
321 }
322
323 /*
324 * Feature: ServiceExtensionContext
325 * Function: startAbility
326 * SubFunction: NA
327 * FunctionPoints: ServiceExtensionContextTest GetAbilityInfoType
328 * EnvConditions: NA
329 * CaseDescription: Verify startAbility
330 */
331 HWTEST_F(ServiceExtensionContextTest, service_extension_context_GetAbilityInfoType_001, TestSize.Level1)
332 {
333 ServiceExtensionContext serviceExtensionContextTest;
334 EXPECT_EQ(AppExecFwk::AbilityType::UNKNOWN, serviceExtensionContextTest.GetAbilityInfoType());
335 }
336
337 /**
338 * @tc.number: service_extension_context_startAbility_003
339 * @tc.name: StartAbility
340 * @tc.desc: Start ability success
341 */
342 HWTEST_F(ServiceExtensionContextTest, service_extension_context_startAbility_003, TestSize.Level1)
343 {
344 GTEST_LOG_(INFO) << "service_extension_context_startAbility_003 start";
345 ServiceExtensionContext serviceExtensionContextTest;
346 sptr<AAFwk::AbilityManagerStubTestMock> mock = new AAFwk::AbilityManagerStubTestMock();
347 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = mock;
348
349 AAFwk::Want want;
350 AppExecFwk::ElementName element("device", "com.ix.hiMusic", "MusicAbility");
351 want.SetElement(element);
352 auto ret = serviceExtensionContextTest.StartAbility(want);
353 EXPECT_EQ(ret, ERR_OK);
354 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = nullptr;
355 GTEST_LOG_(INFO) << "service_extension_context_startAbility_003 end";
356 }
357
358 /**
359 * @tc.number: service_extension_context_StartAbilityWithAccount_003
360 * @tc.name: StartAbility
361 * @tc.desc: Start ability with Account success
362 */
363 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartAbilityWithAccount_003, TestSize.Level1)
364 {
365 GTEST_LOG_(INFO) << "service_extension_context_StartAbilityWithAccount_003 start";
366 ServiceExtensionContext serviceExtensionContextTest;
367 sptr<AAFwk::AbilityManagerStubTestMock> mock = new AAFwk::AbilityManagerStubTestMock();
368 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = mock;
369
370 AAFwk::Want want;
371 AppExecFwk::ElementName element("device", "com.ix.hiMusic", "MusicAbility");
372 want.SetElement(element);
373 int32_t accountId = 1;
374
375 auto ret = serviceExtensionContextTest.StartAbilityWithAccount(want, accountId);
376 EXPECT_EQ(ret, ERR_OK);
377 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = nullptr;
378 GTEST_LOG_(INFO) << "service_extension_context_StartAbilityWithAccount_003 end";
379 }
380
381 /**
382 * @tc.number: service_extension_context_StartServiceExtensionAbility_002
383 * @tc.name: StartAbility
384 * @tc.desc: Start service extension ability success
385 */
386 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartServiceExtensionAbility_002, TestSize.Level1)
387 {
388 GTEST_LOG_(INFO) << "service_extension_context_StartServiceExtensionAbility_002 start";
389 ServiceExtensionContext serviceExtensionContextTest;
390 sptr<AAFwk::AbilityManagerStubTestMock> mock = new AAFwk::AbilityManagerStubTestMock();
391 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = mock;
392
393 AAFwk::Want want;
394 AppExecFwk::ElementName element("device", "com.ix.hiMusic", "MusicAbility");
395 want.SetElement(element);
396 int32_t accountId = 1;
397
398 auto ret = serviceExtensionContextTest.StartServiceExtensionAbility(want, accountId);
399 EXPECT_EQ(ret, ERR_OK);
400 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = nullptr;
401 GTEST_LOG_(INFO) << "service_extension_context_StartServiceExtensionAbility_002 end";
402 }
403
404 /**
405 * @tc.number: service_extension_context_StopServiceExtensionAbility_002
406 * @tc.name: StopServiceExtensionAbility
407 * @tc.desc: Stop service extension ability success
408 */
409 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StopServiceExtensionAbility_002, TestSize.Level1)
410 {
411 GTEST_LOG_(INFO) << "service_extension_context_StopServiceExtensionAbility_002 start";
412 ServiceExtensionContext serviceExtensionContextTest;
413 sptr<AAFwk::AbilityManagerStubTestMock> mock = new AAFwk::AbilityManagerStubTestMock();
414 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = mock;
415
416 AAFwk::Want want;
417 AppExecFwk::ElementName element("device", "com.ix.hiMusic", "MusicAbility");
418 want.SetElement(element);
419 int32_t accountId = 1;
420
421 auto ret = serviceExtensionContextTest.StopServiceExtensionAbility(want, accountId);
422 EXPECT_EQ(ret, ERR_OK);
423 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = nullptr;
424 GTEST_LOG_(INFO) << "service_extension_context_StopServiceExtensionAbility_002 end";
425 }
426
427 /**
428 * @tc.number: service_extension_context_TerminateAbility_002
429 * @tc.name: TerminateAbility
430 * @tc.desc: Terminate ability success
431 */
432 HWTEST_F(ServiceExtensionContextTest, service_extension_context_TerminateAbility_002, TestSize.Level1)
433 {
434 GTEST_LOG_(INFO) << "service_extension_context_TerminateAbility_002 start";
435 ServiceExtensionContext serviceExtensionContextTest;
436 sptr<AAFwk::AbilityManagerStubTestMock> mock = new AAFwk::AbilityManagerStubTestMock();
437 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = mock;
438
439 auto ret = serviceExtensionContextTest.TerminateAbility();
440 EXPECT_EQ(ret, ERR_OK);
441 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = nullptr;
442 GTEST_LOG_(INFO) << "service_extension_context_TerminateAbility_002 end";
443 }
444
445 /**
446 * @tc.number: service_extension_context_ClearFailedCallConnection_001
447 * @tc.name: ClearFailedCallConnection
448 * @tc.desc: clear failed call connection execute normally
449 */
450 HWTEST_F(ServiceExtensionContextTest, service_extension_context_ClearFailedCallConnection_001, TestSize.Level1)
451 {
452 GTEST_LOG_(INFO) << "service_extension_context_ClearFailedCallConnection_001 start";
453 ServiceExtensionContext serviceExtensionContextTest;
454 serviceExtensionContextTest.ClearFailedCallConnection(nullptr);
455 EXPECT_EQ(serviceExtensionContextTest.localCallContainer_, nullptr);
456 serviceExtensionContextTest.localCallContainer_ = std::make_shared<LocalCallContainer>();
457 serviceExtensionContextTest.ClearFailedCallConnection(nullptr);
458 EXPECT_NE(serviceExtensionContextTest.localCallContainer_, nullptr);
459 GTEST_LOG_(INFO) << "service_extension_context_ClearFailedCallConnection_001 end";
460 }
461
462 /**
463 * @tc.number: service_extension_context_StartUIServiceExtensionAbility_001
464 * @tc.name: StartUIServiceExtensionAbility
465 * @tc.desc: Start ui service extension ability success
466 */
467 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartUIServiceExtensionAbility_001, TestSize.Level1)
468 {
469 ServiceExtensionContext serviceExtensionContextTest;
470 Want want;
471 int32_t accountId = 1;
472 StartOptions startOptions;
473 ErrCode result = serviceExtensionContextTest.StartUIServiceExtensionAbility(want, accountId);
474 EXPECT_NE(ERR_OK, result);
475 }
476
477 /**
478 * @tc.number: service_extension_context_StartUIServiceExtensionAbility_002
479 * @tc.name: StartUIServiceExtensionAbility
480 * @tc.desc: Start ui service extension ability success
481 */
482 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartUIServiceExtensionAbility_002, TestSize.Level1)
483 {
484 GTEST_LOG_(INFO) << "service_extension_context_StartUIServiceExtensionAbility_002 start";
485 ServiceExtensionContext serviceExtensionContextTest;
486 sptr<AAFwk::AbilityManagerStubTestMock> mock = new AAFwk::AbilityManagerStubTestMock();
487 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = mock;
488
489 AAFwk::Want want;
490 AppExecFwk::ElementName element("device", "com.ix.hiMusic", "MusicAbility");
491 want.SetElement(element);
492 int32_t accountId = 1;
493
494 auto ret = serviceExtensionContextTest.StartUIServiceExtensionAbility(want, accountId);
495 EXPECT_EQ(ret, ERR_OK);
496 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = nullptr;
497 GTEST_LOG_(INFO) << "service_extension_context_StartUIServiceExtensionAbility_002 end";
498 }
499
500 /**
501 * @tc.number: service_extension_context_ReleaseCall_002
502 * @tc.name: ReleaseCall
503 * @tc.desc: Start ui service extension ability success
504 */
505 HWTEST_F(ServiceExtensionContextTest, service_extension_context_ReleaseCall_002, TestSize.Level1)
506 {
507 ServiceExtensionContext serviceExtensionContextTest;
508 serviceExtensionContextTest.localCallContainer_ = std::make_shared<LocalCallContainer>();
509
510 auto result = serviceExtensionContextTest.ReleaseCall(nullptr);
511 EXPECT_EQ(result, ERR_INVALID_VALUE);
512 }
513
514 /**
515 * @tc.number: service_extension_context_GetAbilityInfoType_002
516 * @tc.name: GetAbilityInfoType
517 * @tc.desc: Start ui service extension ability success
518 */
519 HWTEST_F(ServiceExtensionContextTest, service_extension_context_GetAbilityInfoType_002, TestSize.Level1)
520 {
521 ServiceExtensionContext serviceExtensionContextTest;
522 serviceExtensionContextTest.abilityInfo_ = std::make_shared<OHOS::AppExecFwk::AbilityInfo>();
523 serviceExtensionContextTest.abilityInfo_->type = AppExecFwk::AbilityType::SERVICE;
524
525 auto result = serviceExtensionContextTest.GetAbilityInfoType();
526 EXPECT_EQ(result, AppExecFwk::AbilityType::SERVICE);
527 }
528
529 /**
530 * @tc.number: service_extension_context_AddFreeInstallObserver_002
531 * @tc.name: AddFreeInstallObserver
532 * @tc.desc: Start ui service extension ability success
533 */
534 HWTEST_F(ServiceExtensionContextTest, service_extension_context_AddFreeInstallObserver_002, TestSize.Level1)
535 {
536 ServiceExtensionContext serviceExtensionContextTest;
537 MessageParcel data;
538 sptr<AbilityRuntime::IFreeInstallObserver> observer =
539 iface_cast<AbilityRuntime::IFreeInstallObserver>(data.ReadRemoteObject());
540
541 auto result = serviceExtensionContextTest.AddFreeInstallObserver(nullptr);
542 EXPECT_NE(result, ERR_OK);
543 }
544
545 /**
546 * @tc.number: service_extension_context_PreStartMission_001
547 * @tc.name: PreStartMission
548 * @tc.desc: Start ui service extension ability success
549 */
550 HWTEST_F(ServiceExtensionContextTest, service_extension_context_PreStartMission_001, TestSize.Level1)
551 {
552 ServiceExtensionContext serviceExtensionContextTest;
553
554 auto result = serviceExtensionContextTest.PreStartMission("", "", "", "");
555 EXPECT_NE(result, ERR_OK);
556 }
557
558 /**
559 * @tc.number: service_extension_context_OpenAtomicService_001
560 * @tc.name: OpenAtomicService
561 * @tc.desc: Start ui service extension ability success
562 */
563 HWTEST_F(ServiceExtensionContextTest, service_extension_context_OpenAtomicService_001, TestSize.Level1)
564 {
565 ServiceExtensionContext serviceExtensionContextTest;
566 AAFwk::Want want;
567 AAFwk::StartOptions options;
568
569 auto result = serviceExtensionContextTest.OpenAtomicService(want, options);
570 EXPECT_NE(result, ERR_OK);
571 }
572
573 /**
574 * @tc.number: AddCompletionHandlerForAtomicService_0100
575 * @tc.name: AddCompletionHandlerForAtomicService
576 * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
577 */
578 HWTEST_F(ServiceExtensionContextTest, AddCompletionHandlerForAtomicService_100, Function | MediumTest | Level1)
579 {
580 std::string requestId = "1234567890";
581 std::string appId = "atomic";
582 OnAtomicRequestSuccess onRequestSucc = nullptr;
583 OnAtomicRequestFailure onRequestFail = nullptr;
584 ServiceExtensionContext serviceExtensionContextTest;
585 auto result = serviceExtensionContextTest.AddCompletionHandlerForAtomicService(
586 requestId, onRequestSucc, onRequestFail, appId);
587 EXPECT_EQ(result, ERR_INVALID_VALUE);
588 EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), true);
589 }
590
591 /**
592 * @tc.number: AddCompletionHandlerForAtomicService_0200
593 * @tc.name: AddCompletionHandlerForAtomicService
594 * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
595 */
596 HWTEST_F(ServiceExtensionContextTest, AddCompletionHandlerForAtomicService_0200, Function | MediumTest | Level1)
597 {
598 std::string requestId = "1234567890";
599 std::string appId = "atomic";
__anon6234000c0102(const std::string&) 600 OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
601 OnAtomicRequestFailure onRequestFail = nullptr;
602 ServiceExtensionContext serviceExtensionContextTest;
603 auto result = serviceExtensionContextTest.AddCompletionHandlerForAtomicService(
604 requestId, onRequestSucc, onRequestFail, appId);
605 EXPECT_EQ(result, ERR_INVALID_VALUE);
606 EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), true);
607 }
608
609 /**
610 * @tc.number: AddCompletionHandlerForAtomicService_0300
611 * @tc.name: AddCompletionHandlerForAtomicService
612 * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
613 */
614 HWTEST_F(ServiceExtensionContextTest, AddCompletionHandlerForAtomicService_0300, Function | MediumTest | Level1)
615 {
616 std::string requestId = "1234567890";
617 std::string appId = "atomic";
__anon6234000c0202(const std::string&) 618 OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
__anon6234000c0302(const std::string&, int32_t, const std::string&) 619 OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
620 ServiceExtensionContext serviceExtensionContextTest;
621 auto result = serviceExtensionContextTest.AddCompletionHandlerForAtomicService(
622 requestId, onRequestSucc, onRequestFail, appId);
623 EXPECT_EQ(result, ERR_OK);
624 EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), false);
625 serviceExtensionContextTest.onAtomicRequestResults_.clear();
626 }
627
628 /**
629 * @tc.number: AddCompletionHandlerForAtomicService_0400
630 * @tc.name: AddCompletionHandlerForAtomicService
631 * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
632 */
633 HWTEST_F(ServiceExtensionContextTest, AddCompletionHandlerForAtomicService_0400, Function | MediumTest | Level1)
634 {
635 std::string requestId = "1234567890";
636 std::string appId = "atomic";
__anon6234000c0402(const std::string&) 637 OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
__anon6234000c0502(const std::string&, int32_t, const std::string&) 638 OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
639 ServiceExtensionContext serviceExtensionContextTest;
640 std::string norequestId = "test";
641 serviceExtensionContextTest.onAtomicRequestResults_.clear();
642 serviceExtensionContextTest.onAtomicRequestResults_.emplace_back(
643 std::make_shared<OnAtomicRequestResult>(requestId, appId, onRequestSucc, onRequestFail));
644 auto result = serviceExtensionContextTest.AddCompletionHandlerForAtomicService(
645 requestId, onRequestSucc, onRequestFail, appId);
646 EXPECT_EQ(result, ERR_OK);
647 result = serviceExtensionContextTest.AddCompletionHandlerForAtomicService(
648 norequestId, onRequestSucc, onRequestFail, appId);
649 EXPECT_EQ(result, ERR_OK);
650 EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.size(), 2);
651 serviceExtensionContextTest.onAtomicRequestResults_.clear();
652 }
653
654 /**
655 * @tc.number: OnRequestSuccess_0100
656 * @tc.name: OnRequestSuccess
657 * @tc.desc: Verify that function OnRequestSuccess.
658 */
659 HWTEST_F(ServiceExtensionContextTest, OnRequestSuccess_0100, Function | MediumTest | Level1)
660 {
661 std::string requestId = "1234567890";
662 std::string appId = "atomic";
__anon6234000c0602(const std::string&) 663 OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
__anon6234000c0702(const std::string&, int32_t, const std::string&) 664 OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
665 ServiceExtensionContext serviceExtensionContextTest;
666 auto result = serviceExtensionContextTest.AddCompletionHandlerForAtomicService(
667 requestId, onRequestSucc, onRequestFail, appId);
668 EXPECT_EQ(result, ERR_OK);
669 EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), false);
670 AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
671 serviceExtensionContextTest.OnRequestSuccess(requestId, element, "success");
672 EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), true);
673 }
674
675 /**
676 * @tc.number: OnRequestSuccess_0200
677 * @tc.name: OnRequestSuccess
678 * @tc.desc: Verify that function OnRequestSuccess.
679 */
680 HWTEST_F(ServiceExtensionContextTest, OnRequestSuccess_0200, Function | MediumTest | Level1)
681 {
682 std::string requestId = "1234567890";
683 ServiceExtensionContext serviceExtensionContextTest;
684 EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), true);
685 AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
686 serviceExtensionContextTest.OnRequestSuccess(requestId, element, "success");
687 EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), true);
688 }
689
690 /**
691 * @tc.number: OnRequestSuccess_0300
692 * @tc.name: OnRequestSuccess
693 * @tc.desc: Verify that function OnRequestSuccess.
694 */
695 HWTEST_F(ServiceExtensionContextTest, OnRequestSuccess_0300, Function | MediumTest | Level1)
696 {
697 std::string requestId = "1234567890";
698 std::string appId = "atomic";
__anon6234000c0802(const std::string&) 699 OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
__anon6234000c0902(const std::string&, int32_t, const std::string&) 700 OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
701 ServiceExtensionContext serviceExtensionContextTest;
702 auto result = serviceExtensionContextTest.AddCompletionHandlerForAtomicService(
703 requestId, onRequestSucc, onRequestFail, appId);
704 EXPECT_EQ(result, ERR_OK);
705 EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), false);
706 AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
707 std::string norequestId = "test";
708 serviceExtensionContextTest.OnRequestSuccess(norequestId, element, "success");
709 EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), false);
710 serviceExtensionContextTest.onAtomicRequestResults_.clear();
711 }
712
713 /**
714 * @tc.number: OnRequestFailure_0100
715 * @tc.name: OnRequestFailure
716 * @tc.desc: Verify that function OnRequestFailure.
717 */
718 HWTEST_F(ServiceExtensionContextTest, OnRequestFailure_0100, Function | MediumTest | Level1)
719 {
720 std::string requestId = "1234567890";
721 std::string appId = "atomic";
__anon6234000c0a02(const std::string&) 722 OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
__anon6234000c0b02(const std::string&, int32_t, const std::string&) 723 OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
724 ServiceExtensionContext serviceExtensionContextTest;
725 auto result = serviceExtensionContextTest.AddCompletionHandlerForAtomicService(
726 requestId, onRequestSucc, onRequestFail, appId);
727 EXPECT_EQ(result, ERR_OK);
728 EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), false);
729 AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
730 serviceExtensionContextTest.OnRequestFailure(requestId, element, "failure");
731 EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), true);
732 serviceExtensionContextTest.onAtomicRequestResults_.clear();
733 }
734
735 /**
736 * @tc.number: OnRequestFailure_0200
737 * @tc.name: OnRequestFailure
738 * @tc.desc: Verify that function OnRequestFailure.
739 */
740 HWTEST_F(ServiceExtensionContextTest, OnRequestFailure_0200, Function | MediumTest | Level1)
741 {
742 std::string requestId = "1234567890";
743 ServiceExtensionContext serviceExtensionContextTest;
744 EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), true);
745 AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
746 serviceExtensionContextTest.OnRequestFailure(requestId, element, "failure");
747 EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), true);
748 }
749
750 /**
751 * @tc.number: OnRequestFailure_0300
752 * @tc.name: OnRequestFailure
753 * @tc.desc: Verify that function OnRequestFailure.
754 */
755 HWTEST_F(ServiceExtensionContextTest, OnRequestFailure_0300, Function | MediumTest | Level1)
756 {
757 std::string requestId = "1234567890";
758 std::string appId = "atomic";
__anon6234000c0c02(const std::string&) 759 OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
__anon6234000c0d02(const std::string&, int32_t, const std::string&) 760 OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
761 ServiceExtensionContext contextTest;
762 auto result = contextTest.AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
763 EXPECT_EQ(result, ERR_OK);
764 EXPECT_EQ(contextTest.onAtomicRequestResults_.empty(), false);
765 AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
766 std::string norequestId = "test";
767 contextTest.OnRequestFailure(norequestId, element, "failure");
768 EXPECT_EQ(contextTest.onAtomicRequestResults_.empty(), false);
769 contextTest.onAtomicRequestResults_.clear();
770 }
771
772 /**
773 * @tc.number: GetFailureInfoByMessage_0100
774 * @tc.name: GetFailureInfoByMessage
775 * @tc.desc: Verify that function GetFailureInfoByMessage.
776 */
777 HWTEST_F(ServiceExtensionContextTest, GetFailureInfoByMessage_0100, Function | MediumTest | Level1)
778 {
779 std::string message = "User refused redirection";
780 int32_t faileCode = 0;
781 std::string failReason;
782 ServiceExtensionContext contextTest;
783 int32_t resultCode = USER_CANCEL;
784 contextTest.GetFailureInfoByMessage(message, faileCode, failReason, resultCode);
785 EXPECT_EQ(faileCode, 1);
786 EXPECT_EQ(failReason, "The user canceled this startup");
787 resultCode = 0;
788 contextTest.GetFailureInfoByMessage(message, faileCode, failReason, resultCode);
789 EXPECT_EQ(faileCode, 2);
790 EXPECT_EQ(failReason, "User refused redirection");
791 message = "test";
792 contextTest.GetFailureInfoByMessage(message, faileCode, failReason, resultCode);
793 EXPECT_EQ(faileCode, 0);
794 EXPECT_EQ(failReason, "A system error occurred");
795 }
796 }
797 }
798