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 #define protected public
20 #include "extension_base.h"
21 #include "ui_extension_context.h"
22 #undef private
23 #undef protected
24
25 #include "hilog_tag_wrapper.h"
26 #include "want.h"
27 #include "mock_window.h"
28
29 using namespace testing::ext;
30 using namespace OHOS::Rosen;
31 using testing::Return;
32 using testing::_;
33
34 namespace OHOS {
35 namespace AbilityRuntime {
36 class UIExtensionContextTest : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp() override;
41 void TearDown() override;
42 };
43
SetUpTestCase(void)44 void UIExtensionContextTest::SetUpTestCase(void)
45 {}
46
TearDownTestCase(void)47 void UIExtensionContextTest::TearDownTestCase(void)
48 {}
49
SetUp()50 void UIExtensionContextTest::SetUp()
51 {}
52
TearDown()53 void UIExtensionContextTest::TearDown()
54 {}
55
56 /**
57 * @tc.number: StartAbility_0100
58 * @tc.name: StartAbility
59 * @tc.desc: Start a new ability.
60 */
61 HWTEST_F(UIExtensionContextTest, StartAbility_0100, TestSize.Level1)
62 {
63 TAG_LOGI(AAFwkTag::TEST, "StartAbility_0100 start");
64
65 auto context = std::make_shared<UIExtensionContext>();
66 AAFwk::Want want;
67 ElementName element("device", "ohos.samples", "form_extension_context_test");
68 want.SetElement(element);
69 EXPECT_TRUE(context->StartAbility(want) != ERR_OK);
70
71 TAG_LOGI(AAFwkTag::TEST, "StartAbility_0100 end");
72 }
73
74 /**
75 * @tc.number: StartAbility_0200
76 * @tc.name: StartAbility
77 * @tc.desc: Start a new ability.
78 */
79 HWTEST_F(UIExtensionContextTest, StartAbility_0200, TestSize.Level1)
80 {
81 TAG_LOGI(AAFwkTag::TEST, "StartAbility_0200 start");
82
83 auto context = std::make_shared<UIExtensionContext>();
84 AAFwk::Want want;
85 AAFwk::StartOptions startOptions;
86 ElementName element("device", "ohos.samples", "form_extension_context_test");
87 want.SetElement(element);
88 EXPECT_TRUE(context->StartAbility(want, startOptions) != ERR_OK);
89
90 TAG_LOGI(AAFwkTag::TEST, "StartAbility_0200 end");
91 }
92
93 /**
94 * @tc.number: TerminateSelf_0100
95 * @tc.name: TerminateSelf
96 * @tc.desc: Terminate a ability.
97 */
98 HWTEST_F(UIExtensionContextTest, TerminateSelf_0100, TestSize.Level1)
99 {
100 TAG_LOGI(AAFwkTag::TEST, "TerminateSelf_0100 start");
101
102 auto context = std::make_shared<UIExtensionContext>();
103 auto ret = context->TerminateSelf();
104 EXPECT_EQ(ret, ERR_INVALID_VALUE);
105
106 TAG_LOGI(AAFwkTag::TEST, "TerminateSelf_0100 end");
107 }
108
109 /**
110 * @tc.number: ConnectAbility_0100
111 * @tc.name: ConnectAbility
112 * @tc.desc: Connect a ability.
113 */
114 HWTEST_F(UIExtensionContextTest, ConnectAbility_0100, TestSize.Level1)
115 {
116 TAG_LOGI(AAFwkTag::TEST, "ConnectAbility_0100 start");
117
118 auto context = std::make_shared<UIExtensionContext>();
119 AAFwk::Want want;
120 sptr<AbilityConnectCallback> connectCallback;
121 auto ret = context->ConnectAbility(want, connectCallback);
122 EXPECT_NE(ret, 0);
123
124 TAG_LOGI(AAFwkTag::TEST, "ConnectAbility_0100 end");
125 }
126
127 /**
128 * @tc.number: DisconnectAbility_0100
129 * @tc.name: DisconnectAbility
130 * @tc.desc: Disconnect a ability.
131 */
132 HWTEST_F(UIExtensionContextTest, DisconnectAbility_0100, TestSize.Level1)
133 {
134 TAG_LOGI(AAFwkTag::TEST, "DisconnectAbility_0100 start");
135
136 auto context = std::make_shared<UIExtensionContext>();
137 AAFwk::Want want;
138 sptr<AbilityConnectCallback> connectCallback;
139 auto ret = context->DisconnectAbility(want, connectCallback);
140 EXPECT_NE(ret, 0);
141
142 TAG_LOGI(AAFwkTag::TEST, "DisconnectAbility_0100 end");
143 }
144
145 /**
146 * @tc.number: StartAbilityForResult_0100
147 * @tc.name: StartAbilityForResult
148 * @tc.desc: Start a ability for result.
149 */
150 HWTEST_F(UIExtensionContextTest, StartAbilityForResult_0100, TestSize.Level1)
151 {
152 TAG_LOGI(AAFwkTag::TEST, "StartAbilityForResult_0100 start");
153
154 auto context = std::make_shared<UIExtensionContext>();
155 AAFwk::Want want;
156 AAFwk::StartOptions startOptions;
157 int32_t requestCode = 1;
158 RuntimeTask task = [](const int32_t count, const Want& want, bool isInner)
__anon96583e460102(const int32_t count, const Want& want, bool isInner) 159 { GTEST_LOG_(INFO) << "StartAbilityForResult_0100 task called"; };
160 auto ret = context->StartAbilityForResult(want, startOptions, requestCode, std::move(task));
161 EXPECT_NE(ret, ERR_OK);
162
163 TAG_LOGI(AAFwkTag::TEST, "StartAbilityForResult_0100 end");
164 }
165
166 /**
167 * @tc.number: StartAbilityForResult_0200
168 * @tc.name: StartAbilityForResult
169 * @tc.desc: Start a ability for result.
170 */
171 HWTEST_F(UIExtensionContextTest, StartAbilityForResult_0200, TestSize.Level1)
172 {
173 TAG_LOGI(AAFwkTag::TEST, "StartAbilityForResult_0200 start");
174
175 auto context = std::make_shared<UIExtensionContext>();
176 AAFwk::Want want;
177 int32_t requestCode = 1;
178 RuntimeTask task = [](const int32_t count, const Want& want, bool isInner)
__anon96583e460202(const int32_t count, const Want& want, bool isInner) 179 { GTEST_LOG_(INFO) << "StartAbilityForResult_0200 task called"; };
180 auto ret = context->StartAbilityForResult(want, requestCode, std::move(task));
181 EXPECT_NE(ret, ERR_OK);
182
183 TAG_LOGI(AAFwkTag::TEST, "StartAbilityForResult_0200 end");
184 }
185
186 /**
187 * @tc.number: StartUIAbilities_0100
188 * @tc.name: StartUIAbilities
189 * @tc.desc: StartUIAbilities.
190 */
191 HWTEST_F(UIExtensionContextTest, StartUIAbilities_0100, TestSize.Level1)
192 {
193 TAG_LOGI(AAFwkTag::TEST, "StartUIAbilities_0100 start");
194
195 auto context = std::make_shared<UIExtensionContext>();
196 std::vector<AAFwk::Want> wantList(5);
197 std::string requestKey = "12345";
198 auto ret = context->StartUIAbilities(wantList, requestKey);
199 EXPECT_NE(ret, ERR_OK);
200
201 TAG_LOGI(AAFwkTag::TEST, "StartUIAbilities_0100 end");
202 }
203
204 /**
205 * @tc.number: OnAbilityResult_0100
206 * @tc.name: OnAbilityResult
207 * @tc.desc: On Ability Result.
208 */
209 HWTEST_F(UIExtensionContextTest, OnAbilityResult_0100, TestSize.Level1)
210 {
211 TAG_LOGI(AAFwkTag::TEST, "OnAbilityResult_0100 start");
212
213 auto context = std::make_shared<UIExtensionContext>();
214 int32_t code = 2;
215 int32_t resultCode = 2;
216 AAFwk::Want resultData;
217 context->OnAbilityResult(code, resultCode, resultData);
218 auto count = context->resultCallbacks_.size();
219 EXPECT_EQ(count, 0);
220
221 TAG_LOGI(AAFwkTag::TEST, "OnAbilityResult_0100 end");
222 }
223
224 /**
225 * @tc.number: GenerateCurRequestCode_0100
226 * @tc.name: GenerateCurRequestCode
227 * @tc.desc: GenerateCurRequestCode.
228 */
229 HWTEST_F(UIExtensionContextTest, GenerateCurRequestCode_0100, TestSize.Level1)
230 {
231 TAG_LOGI(AAFwkTag::TEST, "GenerateCurRequestCode_0100 start");
232
233 auto context = std::make_shared<UIExtensionContext>();
234 auto result = context->GenerateCurRequestCode();
235 EXPECT_FALSE(result = 0);
236
237 TAG_LOGI(AAFwkTag::TEST, "GenerateCurRequestCode_0100 end");
238 }
239
240 /**
241 * @tc.number: GetWidow_0100
242 * @tc.name: GetWidow
243 * @tc.desc: GetWidow.
244 */
245 HWTEST_F(UIExtensionContextTest, GetWidow_0100, TestSize.Level1)
246 {
247 TAG_LOGI(AAFwkTag::TEST, "GetWidow_0100 start");
248
249 auto context = std::make_shared<UIExtensionContext>();
250 sptr<MockWindow> window(new (std::nothrow) MockWindow());
251 context->SetWindow(window);
252 EXPECT_TRUE(context->GetWindow() != nullptr);
253
254 TAG_LOGI(AAFwkTag::TEST, "GetWidow_0100 end");
255 }
256
257 /**
258 * @tc.number: GetUIContent_0100
259 * @tc.name: GetUIContent
260 * @tc.desc: GetUIContent.
261 */
262 HWTEST_F(UIExtensionContextTest, GetUIContent_0100, TestSize.Level1)
263 {
264 TAG_LOGI(AAFwkTag::TEST, "GetUIContent_0100 start");
265
266 auto context = std::make_shared<UIExtensionContext>();
267 sptr<MockWindow> window(new (std::nothrow) MockWindow());
268 context->SetWindow(window);
269 Ace::UIContent* content = context->GetUIContent();
270 EXPECT_TRUE(content == nullptr);
271
272 TAG_LOGI(AAFwkTag::TEST, "GetUIContent_0100 end");
273 }
274
275 /**
276 * @tc.number: StartAbilityForResultAsCaller_0100
277 * @tc.name: StartAbilityForResultAsCaller
278 * @tc.desc: StartAbilityForResultAsCaller.
279 */
280 HWTEST_F(UIExtensionContextTest, StartAbilityForResultAsCaller_0100, TestSize.Level1)
281 {
282 TAG_LOGI(AAFwkTag::TEST, "StartAbilityForResultAsCaller_0100 start");
283
284 auto context = std::make_shared<UIExtensionContext>();
285 sptr<MockWindow> window(new (std::nothrow) MockWindow());
286 context->SetWindow(window);
287 AAFwk::Want want;
288 int requestCode = 0;
289 RuntimeTask task = [](const int32_t count, const Want& want, bool isInner)
__anon96583e460302(const int32_t count, const Want& want, bool isInner) 290 { GTEST_LOG_(INFO) << "StartAbilityForResult_0100 task called"; };
291 context->StartAbilityForResultAsCaller(want, requestCode, std::move(task));
292 EXPECT_TRUE(context != nullptr);
293
294 TAG_LOGI(AAFwkTag::TEST, "StartAbilityForResultAsCaller_0100 end");
295 }
296
297 /**
298 * @tc.number: StartAbilityForResultAsCaller_0200
299 * @tc.name: StartAbilityForResultAsCaller
300 * @tc.desc: StartAbilityForResultAsCaller.
301 */
302 HWTEST_F(UIExtensionContextTest, StartAbilityForResultAsCaller_0200, TestSize.Level1)
303 {
304 TAG_LOGI(AAFwkTag::TEST, "StartAbilityForResultAsCaller_0200 start");
305
306 auto context = std::make_shared<UIExtensionContext>();
307 sptr<MockWindow> window(new (std::nothrow) MockWindow());
308 context->SetWindow(window);
309 AAFwk::Want want;
310 AAFwk::StartOptions startOptions;
311 int requestCode = 0;
312 RuntimeTask task = [](const int32_t count, const Want& want, bool isInner)
__anon96583e460402(const int32_t count, const Want& want, bool isInner) 313 { GTEST_LOG_(INFO) << "StartAbilityForResult_0100 task called"; };
314 context->StartAbilityForResultAsCaller(want, startOptions, requestCode, std::move(task));
315 EXPECT_TRUE(context != nullptr);
316
317 TAG_LOGI(AAFwkTag::TEST, "StartAbilityForResultAsCaller_0200 end");
318 }
319
320 /**
321 * @tc.number: ReportDrawnCompleted_0100
322 * @tc.name: ReportDrawnCompleted
323 * @tc.desc: ReportDrawnCompleted.
324 */
325 HWTEST_F(UIExtensionContextTest, ReportDrawnCompleted_0100, TestSize.Level1)
326 {
327 TAG_LOGI(AAFwkTag::TEST, "ReportDrawnCompleted_0100 start");
328
329 auto context = std::make_shared<UIExtensionContext>();
330 sptr<MockWindow> window(new (std::nothrow) MockWindow());
331 context->SetWindow(window);
332 context->ReportDrawnCompleted();
333 EXPECT_TRUE(context != nullptr);
334
335 TAG_LOGI(AAFwkTag::TEST, "ReportDrawnCompleted_0100 end");
336 }
337
338 /**
339 * @tc.number: InsertResultCallbackTask_0100
340 * @tc.name: InsertResultCallbackTask
341 * @tc.desc: InsertResultCallbackTask.
342 */
343 HWTEST_F(UIExtensionContextTest, InsertResultCallbackTask_0100, TestSize.Level1)
344 {
345 TAG_LOGI(AAFwkTag::TEST, "InsertResultCallbackTask_0100 start");
346
347 auto context = std::make_shared<UIExtensionContext>();
348 sptr<MockWindow> window(new (std::nothrow) MockWindow());
349 context->SetWindow(window);
350 int requestCode = 0;
351 RuntimeTask task = [](const int32_t count, const Want& want, bool isInner)
__anon96583e460502(const int32_t count, const Want& want, bool isInner) 352 { GTEST_LOG_(INFO) << "StartAbilityForResult_0100 task called"; };
353 context->InsertResultCallbackTask(requestCode, std::move(task));
354 EXPECT_TRUE(context != nullptr);
355
356 TAG_LOGI(AAFwkTag::TEST, "InsertResultCallbackTask_0100 end");
357 }
358
359 /**
360 * @tc.number: OpenAtomicService_0100
361 * @tc.name: OpenAtomicService
362 * @tc.desc: OpenAtomicService.
363 */
364 HWTEST_F(UIExtensionContextTest, OpenAtomicService_0100, TestSize.Level1)
365 {
366 TAG_LOGI(AAFwkTag::TEST, "OpenAtomicService_0100 start");
367
368 auto context = std::make_shared<UIExtensionContext>();
369 sptr<MockWindow> window(new (std::nothrow) MockWindow());
370 context->SetWindow(window);
371 AAFwk::Want want;
372 AAFwk::StartOptions startOptions;
373 int requestCode = 0;
374 RuntimeTask task = [](const int32_t count, const Want& want, bool isInner)
__anon96583e460602(const int32_t count, const Want& want, bool isInner) 375 { GTEST_LOG_(INFO) << "StartAbilityForResult_0100 task called"; };
376 context->OpenAtomicService(want, startOptions, requestCode, std::move(task));
377 EXPECT_TRUE(context != nullptr);
378
379 TAG_LOGI(AAFwkTag::TEST, "OpenAtomicService_0100 end");
380 }
381
382 /**
383 * @tc.number: ConvertTo_0100
384 * @tc.name: ConvertTo
385 * @tc.desc: ConvertTo.
386 */
387 HWTEST_F(UIExtensionContextTest, ConvertTo_0100, TestSize.Level1)
388 {
389 TAG_LOGI(AAFwkTag::TEST, "ConvertTo_0100 start");
390 std::shared_ptr<Context> context = std::make_shared<UIExtensionContext>();
391 auto uiHolderExtensionContext = Context::ConvertTo<UIHolderExtensionContext>(context);
392 EXPECT_NE(uiHolderExtensionContext, nullptr);
393 auto uiExtensionContext = Context::ConvertTo<UIExtensionContext>(context);
394 EXPECT_NE(uiExtensionContext, nullptr);
395 TAG_LOGI(AAFwkTag::TEST, "ConvertTo_0100 end");
396 }
397
398 /**
399 * @tc.number: OpenLink_0100
400 * @tc.name: OpenLink
401 * @tc.desc: OpenLink.
402 */
403 HWTEST_F(UIExtensionContextTest, OpenLink_0100, TestSize.Level1)
404 {
405 TAG_LOGI(AAFwkTag::TEST, "OpenLink_0100 start");
406 AAFwk::Want want;
407 int requestCode = 0;
408 auto context = std::make_shared<UIExtensionContext>();
409 EXPECT_NE(context, nullptr);
410 context->OpenLink(want, requestCode);
411 EXPECT_TRUE(context != nullptr);
412 TAG_LOGI(AAFwkTag::TEST, "OpenLink_0100 end");
413 }
414
415 /**
416 * @tc.number: RemoveResultCallbackTask_0100
417 * @tc.name: RemoveResultCallbackTask
418 * @tc.desc: RemoveResultCallbackTask.
419 */
420 HWTEST_F(UIExtensionContextTest, RemoveResultCallbackTask_0100, TestSize.Level1)
421 {
422 TAG_LOGI(AAFwkTag::TEST, "RemoveResultCallbackTask_0100 start");
423 auto context = std::make_shared<UIExtensionContext>();
424 EXPECT_NE(context, nullptr);
425 sptr<MockWindow> window(new (std::nothrow) MockWindow());
426 context->SetWindow(window);
427 int requestCode = 0;
__anon96583e460702(const int32_t count, const Want &want, bool isInner) 428 RuntimeTask task = [](const int32_t count, const Want &want, bool isInner) {
429 GTEST_LOG_(INFO) << "RemoveResultCallbackTask_0100 task called";
430 };
431 context->InsertResultCallbackTask(requestCode, std::move(task));
432 context->RemoveResultCallbackTask(requestCode);
433 auto count = context->resultCallbacks_.size();
434 EXPECT_EQ(count, 0);
435 TAG_LOGI(AAFwkTag::TEST, "RemoveResultCallbackTask_0100 end");
436 }
437
438 /**
439 * @tc.number: AddFreeInstallObserver_0100
440 * @tc.name: AddFreeInstallObserver
441 * @tc.desc: AddFreeInstallObserver.
442 */
443 HWTEST_F(UIExtensionContextTest, AddFreeInstallObserver_0100, TestSize.Level1)
444 {
445 TAG_LOGI(AAFwkTag::TEST, "AddFreeInstallObserver_0100 start");
446 sptr<IFreeInstallObserver> observer;
447 auto context = std::make_shared<UIExtensionContext>();
448 EXPECT_NE(context, nullptr);
449 context->AddFreeInstallObserver(observer);
450 EXPECT_TRUE(context != nullptr);
451 TAG_LOGI(AAFwkTag::TEST, "AddFreeInstallObserver_0100 end");
452 }
453
454 /**
455 * @tc.number: StartUIServiceExtension_0100
456 * @tc.name: StartUIServiceExtension
457 * @tc.desc: StartUIServiceExtension.
458 */
459 HWTEST_F(UIExtensionContextTest, StartUIServiceExtension_0100, TestSize.Level1)
460 {
461 TAG_LOGI(AAFwkTag::TEST, "StartUIServiceExtension_0100 start");
462 AAFwk::Want want;
463 int32_t accountId = 1;
464 auto context = std::make_shared<UIExtensionContext>();
465 EXPECT_NE(context, nullptr);
466 auto ans = context->StartUIServiceExtension(want, accountId);
467 EXPECT_TRUE(ans != ERR_OK);
468 TAG_LOGI(AAFwkTag::TEST, "StartUIServiceExtension_0100 end");
469 }
470
471 /**
472 * @tc.number: SetAbilityResourceManager_0100
473 * @tc.name: SetAbilityResourceManager
474 * @tc.desc: SetAbilityResourceManager.
475 */
476 HWTEST_F(UIExtensionContextTest, SetAbilityResourceManager_0100, TestSize.Level1)
477 {
478 std::shared_ptr<Global::Resource::ResourceManager>
479 abilityResourceMgr(Global::Resource::CreateResourceManager());
480 auto context = std::make_shared<UIExtensionContext>();
481 context->SetAbilityResourceManager(abilityResourceMgr);
482 EXPECT_EQ(context->abilityResourceMgr_, abilityResourceMgr);
483 }
484
485 /**
486 * @tc.number: RegisterAbilityConfigUpdateCallback_0100
487 * @tc.name: RegisterAbilityConfigUpdateCallback
488 * @tc.desc: RegisterAbilityConfigUpdateCallback.
489 */
490 HWTEST_F(UIExtensionContextTest, RegisterAbilityConfigUpdateCallback_0100, TestSize.Level1)
491 {
492 auto context = std::make_shared<UIExtensionContext>();
__anon96583e460802(const AppExecFwk::Configuration &config) 493 auto abilityConfigCallback = [](const AppExecFwk::Configuration &config) {};
494 context->RegisterAbilityConfigUpdateCallback(abilityConfigCallback);
495 EXPECT_NE(context->abilityConfigUpdateCallback_, nullptr);
496 }
497
498 /**
499 * @tc.number: GetAbilityConfiguration_0100
500 * @tc.name: GetAbilityConfiguration
501 * @tc.desc: GetAbilityConfiguration.
502 */
503 HWTEST_F(UIExtensionContextTest, GetAbilityConfiguration_0100, TestSize.Level1)
504 {
505 auto context = std::make_shared<UIExtensionContext>();
506 context->abilityConfiguration_ = std::make_shared<AppExecFwk::Configuration>();
507 auto test = context->GetAbilityConfiguration();
508 EXPECT_NE(test, nullptr);
509 }
510
511 /**
512 * @tc.number: SetAbilityConfiguration_0100
513 * @tc.name: SetAbilityConfiguration
514 * @tc.desc: SetAbilityConfiguration.
515 */
516 HWTEST_F(UIExtensionContextTest, SetAbilityConfiguration_0100, TestSize.Level1)
517 {
518 auto context = std::make_shared<UIExtensionContext>();
519 ASSERT_TRUE(context->abilityConfiguration_ == nullptr);
520 AppExecFwk::Configuration config;
521 context->SetAbilityConfiguration(config);
522 EXPECT_NE(context->abilityConfiguration_, nullptr);
523 }
524
525 /**
526 * @tc.number: SetAbilityColorMode_0100
527 * @tc.name: SetAbilityColorMode
528 * @tc.desc: SetAbilityColorMode.
529 */
530 HWTEST_F(UIExtensionContextTest, SetAbilityColorMode_0100, TestSize.Level1)
531 {
532 auto context = std::make_shared<UIExtensionContext>();
533 int32_t colorMode = -2;
534 context->SetAbilityColorMode(colorMode);
535 colorMode = 0;
536 context->SetAbilityColorMode(colorMode);
537 context->abilityConfigUpdateCallback_ = nullptr;
__anon96583e460902(const AppExecFwk::Configuration &config) 538 auto abilityConfigCallback = [](const AppExecFwk::Configuration &config) {};
539 context->abilityConfigUpdateCallback_ = abilityConfigCallback;
540 context->SetAbilityColorMode(colorMode);
541 EXPECT_NE(context, nullptr);
542 }
543
544 /**
545 * @tc.number: SetScreenMode_0100
546 * @tc.name: SetScreenMode
547 * @tc.desc: SetScreenMode.
548 */
549 HWTEST_F(UIExtensionContextTest, SetScreenMode_0100, TestSize.Level1)
550 {
551 TAG_LOGI(AAFwkTag::TEST, "SetScreenMode_0100 start");
552
553 auto context = std::make_shared<UIExtensionContext>();
554 int32_t mode = 1;
555 context->SetScreenMode(mode);
556 EXPECT_EQ(context->screenMode_, mode);
557
558 TAG_LOGI(AAFwkTag::TEST, "SetScreenMode_0100 end");
559 }
560
561 /**
562 * @tc.number: GetScreenMode_0100
563 * @tc.name: GetScreenMode
564 * @tc.desc: GetScreenMode.
565 */
566 HWTEST_F(UIExtensionContextTest, GetScreenMode_0100, TestSize.Level1)
567 {
568 TAG_LOGI(AAFwkTag::TEST, "GetScreenMode_0100 start");
569
570 auto context = std::make_shared<UIExtensionContext>();
571 int32_t mode = 1;
572 context->screenMode_ = mode;
573 auto test = context->GetScreenMode();
574 EXPECT_EQ(test, mode);
575
576 TAG_LOGI(AAFwkTag::TEST, "GetScreenMode_0100 end");
577 }
578
579 /**
580 * @tc.number: StartServiceExtensionAbility_0100
581 * @tc.name: StartServiceExtensionAbility
582 * @tc.desc: StartServiceExtensionAbility.
583 */
584 HWTEST_F(UIExtensionContextTest, StartServiceExtensionAbility_0100, TestSize.Level1)
585 {
586 TAG_LOGI(AAFwkTag::TEST, "StartServiceExtensionAbility_0100 start");
587 auto context = std::make_shared<UIExtensionContext>();
588 EXPECT_NE(context, nullptr);
589 const AAFwk::Want want;
590 auto ret = context->StartServiceExtensionAbility(want, -1);
591 EXPECT_NE(ret, ERR_OK);
592 TAG_LOGI(AAFwkTag::TEST, "StartServiceExtensionAbility_0100 end");
593 }
594
595 /**
596 * @tc.number: GetAbilityInfoType_0100
597 * @tc.name: GetAbilityInfoType
598 * @tc.desc: GetAbilityInfoType.
599 */
600 HWTEST_F(UIExtensionContextTest, GetAbilityInfoType_0100, TestSize.Level1)
601 {
602 TAG_LOGI(AAFwkTag::TEST, "GetAbilityInfoType_0100 start");
603
604 auto context = std::make_shared<UIExtensionContext>();
605 EXPECT_NE(context, nullptr);
606 auto result = context->GetAbilityInfoType();
607 EXPECT_EQ(result, OHOS::AppExecFwk::AbilityType::UNKNOWN);
608 context->abilityInfo_ = std::make_shared<OHOS::AppExecFwk::AbilityInfo>();
609 context->abilityInfo_->type = OHOS::AppExecFwk::AbilityType::SERVICE;
610 result = context->GetAbilityInfoType();
611 EXPECT_EQ(result, OHOS::AppExecFwk::AbilityType::SERVICE);
612
613 TAG_LOGI(AAFwkTag::TEST, "GetAbilityInfoType_0100 end");
614 }
615
616 /**
617 * @tc.number: StartUIAbilities_1000
618 * @tc.name: StartUIAbilities
619 * @tc.desc: Start abilitys.
620 */
621 HWTEST_F(UIExtensionContextTest, StartUIAbilities_1000, TestSize.Level1)
622 {
623 TAG_LOGI(AAFwkTag::TEST, "StartUIAbilities_1000 start");
624
625 auto context = std::make_shared<UIExtensionContext>();
626 std::vector<AAFwk::Want> wantList;
627 std::string requestKey = "12345";
628 EXPECT_TRUE(context->StartUIAbilities(wantList, requestKey) != ERR_OK);
629
630 TAG_LOGI(AAFwkTag::TEST, "StartUIAbilities_1000 end");
631 }
632
633 /**
634 * @tc.number: StartAbility_0300
635 * @tc.name: StartAbility
636 * @tc.desc: Start a new ability.
637 */
638 HWTEST_F(UIExtensionContextTest, StartAbility_0300, TestSize.Level1)
639 {
640 TAG_LOGI(AAFwkTag::TEST, "StartAbility_0200 start");
641
642 auto context = std::make_shared<UIExtensionContext>();
643 AAFwk::Want want;
644 int requestCode = 1;
645 EXPECT_TRUE(context->StartAbility(want, requestCode) != ERR_OK);
646
647 TAG_LOGI(AAFwkTag::TEST, "StartAbility_0200 end");
648 }
649
650 /**
651 * @tc.number: OnAbilityResult_0200
652 * @tc.name: OnAbilityResult
653 * @tc.desc: On Ability Result.
654 */
655 HWTEST_F(UIExtensionContextTest, OnAbilityResult_0200, TestSize.Level1)
656 {
657 TAG_LOGI(AAFwkTag::TEST, "OnAbilityResult_0200 start");
658
659 auto context = std::make_shared<UIExtensionContext>();
660 int32_t code = 2;
661 int32_t resultCode = 2;
662 AAFwk::Want resultData;
663 bool dealed = false;
__anon96583e460a02(int, const AAFwk::Want &, bool) 664 auto runtimeTask = [&dealed](int, const AAFwk::Want &, bool) { dealed = true; };
665 context->resultCallbacks_.insert(std::make_pair(code, runtimeTask));
666 EXPECT_NE(context->resultCallbacks_.size(), 0);
667 context->OnAbilityResult(code, resultCode, resultData);
668 EXPECT_EQ(dealed, true);
669 EXPECT_EQ(context->resultCallbacks_.size(), 0);
670
671 TAG_LOGI(AAFwkTag::TEST, "OnAbilityResult_0200 start");
672 }
673
674 /**
675 * @tc.number: SetAbilityConfiguration_0200
676 * @tc.name: SetAbilityConfiguration
677 * @tc.desc: SetAbilityConfiguration.
678 */
679 HWTEST_F(UIExtensionContextTest, SetAbilityConfiguration_0200, TestSize.Level1)
680 {
681 auto context = std::make_shared<UIExtensionContext>();
682 context->abilityConfiguration_ = std::make_shared<AppExecFwk::Configuration>();
683 EXPECT_NE(context->abilityConfiguration_, nullptr);
684 AppExecFwk::Configuration config;
685 context->SetAbilityConfiguration(config);
686
687 std::string val{ "中文" };
688 context->abilityConfiguration_->AddItem(1001, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, val);
689
690 std::string English{ "中文" };
691 config.AddItem(1002, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, English);
692 context->SetAbilityConfiguration(config);
693 auto result = context->abilityConfiguration_->GetItem(1002, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
694 EXPECT_EQ(result, English);
695 }
696
697 /**
698 * @tc.number: GetResourceManager_0100
699 * @tc.name: GetResourceManager
700 * @tc.desc: GetResourceManager.
701 */
702 HWTEST_F(UIExtensionContextTest, GetResourceManager_0100, TestSize.Level1)
703 {
704 auto context = std::make_shared<UIExtensionContext>();
705 std::shared_ptr<Global::Resource::ResourceManager> resourceMgr(Global::Resource::CreateResourceManager());
706 context->resourceManager_ = resourceMgr;
707 auto ref = context->GetResourceManager();
708 EXPECT_NE(ref, nullptr);
709 }
710
711 /**
712 * @tc.number: RequestComponentTerminate_0100
713 * @tc.name: RequestComponentTerminate
714 * @tc.desc: RequestComponentTerminate with all conditions required, transfer data ok.
715 */
716 HWTEST_F(UIExtensionContextTest, RequestComponentTerminate_0100, TestSize.Level1)
717 {
718 auto context = std::make_shared<UIExtensionContext>();
719 sptr<MockWindow> window = sptr<MockWindow>::MakeSptr();
720 EXPECT_CALL(*window, TransferExtensionData(_)).Times(1).WillOnce(Return(Rosen::WMError::WM_OK));
721 context->SetWindow(window);
722 context->RequestComponentTerminate();
723 }
724
725 /**
726 * @tc.number: RequestComponentTerminate_0200
727 * @tc.name: RequestComponentTerminate
728 * @tc.desc: RequestComponentTerminate with all conditions required, transfer data not ok.
729 */
730 HWTEST_F(UIExtensionContextTest, RequestComponentTerminate_0200, TestSize.Level1)
731 {
732 auto context = std::make_shared<UIExtensionContext>();
733 sptr<MockWindow> window = sptr<MockWindow>::MakeSptr();
734 EXPECT_CALL(*window, TransferExtensionData(_)).Times(1).WillOnce(Return(Rosen::WMError::WM_DO_NOTHING));
735 context->SetWindow(window);
736 context->RequestComponentTerminate();
737 }
738
739 /**
740 * @tc.number: StartAbilityByType_0100
741 * @tc.name: UIExtensionContext StartAbilityByType
742 * @tc.desc: UIExtensionContext StartAbilityByType.
743 */
744 HWTEST_F(UIExtensionContextTest, StartAbilityByType_0100, TestSize.Level1)
745 {
746 TAG_LOGI(AAFwkTag::TEST, "StartAbilityByType_0100 start");
747
748 std::string type;
749 AAFwk::WantParams wantParam;
750 std::shared_ptr<JsUIExtensionCallback> uiExtensionCallbacks{nullptr};
751
752 auto context = std::make_shared<UIExtensionContext>();
753 auto result = context->StartAbilityByType(type, wantParam, uiExtensionCallbacks);
754 EXPECT_EQ(result, ERR_INVALID_VALUE);
755
756 TAG_LOGI(AAFwkTag::TEST, "StartAbilityByType_0100 end");
757 }
758
759 /**
760 * @tc.number: StartAbilityByType_0200
761 * @tc.name: UIExtensionContext StartAbilityByType
762 * @tc.desc: UIExtensionContext StartAbilityByType.
763 */
764 HWTEST_F(UIExtensionContextTest, StartAbilityByType_0200, TestSize.Level1)
765 {
766 TAG_LOGI(AAFwkTag::TEST, "StartAbilityByType_0200 start");
767
768 std::string type;
769 AAFwk::WantParams wantParam;
770 napi_env env;
771 std::shared_ptr<JsUIExtensionCallback> uiExtensionCallbacks = std::make_shared<JsUIExtensionCallback>(env);
772
773 auto context = std::make_shared<UIExtensionContext>();
774 context->SetWindow(nullptr);
775 auto result = context->StartAbilityByType(type, wantParam, uiExtensionCallbacks);
776 EXPECT_EQ(result, ERR_INVALID_VALUE);
777
778 TAG_LOGI(AAFwkTag::TEST, "StartAbilityByType_0200 end");
779 }
780
781 /**
782 * @tc.number: StartAbilityByType_0300
783 * @tc.name: UIExtensionContext StartAbilityByType
784 * @tc.desc: UIExtensionContext StartAbilityByType.
785 */
786 HWTEST_F(UIExtensionContextTest, StartAbilityByType_0300, TestSize.Level1)
787 {
788 TAG_LOGI(AAFwkTag::TEST, "StartAbilityByType_0300 start");
789
790 std::string type;
791 AAFwk::WantParams wantParam;
792 napi_env env;
793 std::shared_ptr<JsUIExtensionCallback> uiExtensionCallbacks = std::make_shared<JsUIExtensionCallback>(env);
794 sptr<Rosen::Window> window = new MockWindow();
795
796 auto context = std::make_shared<UIExtensionContext>();
797 context->SetWindow(window);
798 auto result = context->StartAbilityByType(type, wantParam, uiExtensionCallbacks);
799 EXPECT_EQ(result, ERR_INVALID_VALUE);
800
801 TAG_LOGI(AAFwkTag::TEST, "StartAbilityByType_0300 end");
802 }
803
804 /**
805 * @tc.number: StartAbilityByType_0400
806 * @tc.name: UIExtensionContext StartAbilityByType
807 * @tc.desc: UIExtensionContext StartAbilityByType.
808 */
809 HWTEST_F(UIExtensionContextTest, StartAbilityByType_0400, TestSize.Level1)
810 {
811 TAG_LOGI(AAFwkTag::TEST, "StartAbilityByType_0400 start");
812
813 std::string type;
814 AAFwk::WantParams wantParam;
815 const std::string FLAG_AUTH_READ_URI_PERMISSION = "ability.want.params.uriPermissionFlag";
816 wantParam.SetParam(FLAG_AUTH_READ_URI_PERMISSION, 0);
817 napi_env env;
818 std::shared_ptr<JsUIExtensionCallback> uiExtensionCallbacks = std::make_shared<JsUIExtensionCallback>(env);
819 sptr<Rosen::Window> window = new MockWindow();
820
821 auto context = std::make_shared<UIExtensionContext>();
822 context->SetWindow(window);
823 auto result = context->StartAbilityByType(type, wantParam, uiExtensionCallbacks);
824 EXPECT_EQ(result, ERR_INVALID_VALUE);
825
826 TAG_LOGI(AAFwkTag::TEST, "StartAbilityByType_0400 end");
827 }
828
829 /**
830 * @tc.number: IsTerminating_0100
831 * @tc.name: UIExtensionContext IsTerminating
832 * @tc.desc: UIExtensionContext IsTerminating.
833 */
834 HWTEST_F(UIExtensionContextTest, IsTerminating_0100, TestSize.Level1)
835 {
836 auto context = std::make_shared<UIExtensionContext>();
837 context->SetTerminating(true);
838 EXPECT_TRUE(context->IsTerminating());
839 }
840
841 /**
842 * @tc.number: AddCompletionHandlerForAtomicService_0100
843 * @tc.name: AddCompletionHandlerForAtomicService
844 * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
845 */
846 HWTEST_F(UIExtensionContextTest, AddCompletionHandlerForAtomicService_100, Function | MediumTest | Level1)
847 {
848 std::string requestId = "1234567890";
849 std::string appId = "atomic";
850 OnAtomicRequestSuccess onRequestSucc = nullptr;
851 OnAtomicRequestFailure onRequestFail = nullptr;
852 auto context = std::make_shared<UIExtensionContext>();
853 ASSERT_NE(context, nullptr);
854 auto result = context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
855 EXPECT_EQ(result, ERR_INVALID_VALUE);
856 EXPECT_EQ(context->onAtomicRequestResults_.empty(), true);
857 }
858
859 /**
860 * @tc.number: AddCompletionHandlerForAtomicService_0200
861 * @tc.name: AddCompletionHandlerForAtomicService
862 * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
863 */
864 HWTEST_F(UIExtensionContextTest, AddCompletionHandlerForAtomicService_0200, Function | MediumTest | Level1)
865 {
866 std::string requestId = "1234567890";
867 std::string appId = "atomic";
__anon96583e460b02(const std::string&) 868 OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
869 OnAtomicRequestFailure onRequestFail = nullptr;
870 auto context = std::make_shared<UIExtensionContext>();
871 ASSERT_NE(context, nullptr);
872 auto result = context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
873 EXPECT_EQ(result, ERR_INVALID_VALUE);
874 EXPECT_EQ(context->onAtomicRequestResults_.empty(), true);
875 }
876
877 /**
878 * @tc.number: AddCompletionHandlerForAtomicService_0300
879 * @tc.name: AddCompletionHandlerForAtomicService
880 * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
881 */
882 HWTEST_F(UIExtensionContextTest, AddCompletionHandlerForAtomicService_0300, Function | MediumTest | Level1)
883 {
884 std::string requestId = "1234567890";
885 std::string appId = "atomic";
__anon96583e460c02(const std::string&) 886 OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
__anon96583e460d02(const std::string&, int32_t, const std::string&) 887 OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
888 auto context = std::make_shared<UIExtensionContext>();
889 ASSERT_NE(context, nullptr);
890 auto result = context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
891 EXPECT_EQ(result, ERR_OK);
892 EXPECT_EQ(context->onAtomicRequestResults_.empty(), false);
893 context->onAtomicRequestResults_.clear();
894 }
895
896 /**
897 * @tc.number: AddCompletionHandler_0400
898 * @tc.name: AddCompletionHandlerForAtomicService
899 * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
900 */
901 HWTEST_F(UIExtensionContextTest, AddCompletionHandler_0400, Function | MediumTest | Level1)
902 {
903 std::string requestId = "1234567890";
904 std::string appId = "atomic";
__anon96583e460e02(const std::string&) 905 OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
__anon96583e460f02(const std::string&, int32_t, const std::string&) 906 OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
907 auto context = std::make_shared<UIExtensionContext>();
908 ASSERT_NE(context, nullptr);
909 context->onAtomicRequestResults_.emplace_back(
910 std::make_shared<OnAtomicRequestResult>(requestId, appId, onRequestSucc, onRequestFail));
911 auto result = context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
912 EXPECT_EQ(result, ERR_OK);
913 std::string norequestId = "test";
914 result = context->AddCompletionHandlerForAtomicService(norequestId, onRequestSucc, onRequestFail, appId);
915 EXPECT_EQ(context->onAtomicRequestResults_.size(), 2);
916 context->onAtomicRequestResults_.clear();
917 }
918
919 /**
920 * @tc.number: OnRequestSuccess_0100
921 * @tc.name: OnRequestSuccess
922 * @tc.desc: Verify that function OnRequestSuccess.
923 */
924 HWTEST_F(UIExtensionContextTest, OnRequestSuccess_0100, Function | MediumTest | Level1)
925 {
926 std::string requestId = "1234567890";
927 std::string appId = "atomic";
__anon96583e461002(const std::string&) 928 OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
__anon96583e461102(const std::string&, int32_t, const std::string&) 929 OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
930 auto context = std::make_shared<UIExtensionContext>();
931 ASSERT_NE(context, nullptr);
932 auto result = context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
933 EXPECT_EQ(result, ERR_OK);
934 EXPECT_EQ(context->onAtomicRequestResults_.empty(), false);
935 AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
936 context->OnRequestSuccess(requestId, element, "success");
937 EXPECT_EQ(context->onAtomicRequestResults_.empty(), true);
938 }
939
940 /**
941 * @tc.number: OnRequestSuccess_0200
942 * @tc.name: OnRequestSuccess
943 * @tc.desc: Verify that function OnRequestSuccess.
944 */
945 HWTEST_F(UIExtensionContextTest, OnRequestSuccess_0200, Function | MediumTest | Level1)
946 {
947 std::string requestId = "1234567890";
948 auto context = std::make_shared<UIExtensionContext>();
949 ASSERT_NE(context, nullptr);
950 EXPECT_EQ(context->onAtomicRequestResults_.empty(), true);
951 AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
952 context->OnRequestSuccess(requestId, element, "success");
953 EXPECT_EQ(context->onAtomicRequestResults_.empty(), true);
954 }
955
956 /**
957 * @tc.number: OnRequestSuccess_0300
958 * @tc.name: OnRequestSuccess
959 * @tc.desc: Verify that function OnRequestSuccess.
960 */
961 HWTEST_F(UIExtensionContextTest, OnRequestSuccess_0300, Function | MediumTest | Level1)
962 {
963 std::string requestId = "1234567890";
964 std::string appId = "atomic";
__anon96583e461202(const std::string&) 965 OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
__anon96583e461302(const std::string&, int32_t, const std::string&) 966 OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
967 auto context = std::make_shared<UIExtensionContext>();
968 ASSERT_NE(context, nullptr);
969 auto result = context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
970 EXPECT_EQ(result, ERR_OK);
971 EXPECT_EQ(context->onAtomicRequestResults_.empty(), false);
972 AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
973 std::string norequestId = "test";
974 context->OnRequestSuccess(norequestId, element, "success");
975 EXPECT_EQ(context->onAtomicRequestResults_.empty(), false);
976 context->onAtomicRequestResults_.clear();
977 }
978
979 /**
980 * @tc.number: OnRequestFailure_0100
981 * @tc.name: OnRequestFailure
982 * @tc.desc: Verify that function OnRequestFailure.
983 */
984 HWTEST_F(UIExtensionContextTest, OnRequestFailure_0100, Function | MediumTest | Level1)
985 {
986 std::string requestId = "1234567890";
987 std::string appId = "atomic";
__anon96583e461402(const std::string&) 988 OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
__anon96583e461502(const std::string&, int32_t, const std::string&) 989 OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
990 auto context = std::make_shared<UIExtensionContext>();
991 ASSERT_NE(context, nullptr);
992 auto result = context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
993 EXPECT_EQ(result, ERR_OK);
994 EXPECT_EQ(context->onAtomicRequestResults_.empty(), false);
995 AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
996 context->OnRequestFailure(requestId, element, "failure");
997 EXPECT_EQ(context->onAtomicRequestResults_.empty(), true);
998 context->onAtomicRequestResults_.clear();
999 }
1000
1001 /**
1002 * @tc.number: OnRequestFailure_0200
1003 * @tc.name: OnRequestFailure
1004 * @tc.desc: Verify that function OnRequestFailure.
1005 */
1006 HWTEST_F(UIExtensionContextTest, OnRequestFailure_0200, Function | MediumTest | Level1)
1007 {
1008 std::string requestId = "1234567890";
1009 auto context = std::make_shared<UIExtensionContext>();
1010 ASSERT_NE(context, nullptr);
1011 EXPECT_EQ(context->onAtomicRequestResults_.empty(), true);
1012 AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
1013 context->OnRequestFailure(requestId, element, "failure");
1014 EXPECT_EQ(context->onAtomicRequestResults_.empty(), true);
1015 }
1016
1017 /**
1018 * @tc.number: OnRequestFailure_0300
1019 * @tc.name: OnRequestFailure
1020 * @tc.desc: Verify that function OnRequestFailure.
1021 */
1022 HWTEST_F(UIExtensionContextTest, OnRequestFailure_0300, Function | MediumTest | Level1)
1023 {
1024 std::string requestId = "1234567890";
1025 std::string appId = "atomic";
__anon96583e461602(const std::string&) 1026 OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
__anon96583e461702(const std::string&, int32_t, const std::string&) 1027 OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
1028 auto context = std::make_shared<UIExtensionContext>();
1029 ASSERT_NE(context, nullptr);
1030 auto result = context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
1031 EXPECT_EQ(result, ERR_OK);
1032 EXPECT_EQ(context->onAtomicRequestResults_.empty(), false);
1033 AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
1034 std::string norequestId = "test";
1035 context->OnRequestFailure(norequestId, element, "failure");
1036 EXPECT_EQ(context->onAtomicRequestResults_.empty(), false);
1037 context->onAtomicRequestResults_.clear();
1038 }
1039
1040 /**
1041 * @tc.number: GetFailureInfoByMessage_0100
1042 * @tc.name: GetFailureInfoByMessage
1043 * @tc.desc: Verify that function GetFailureInfoByMessage.
1044 */
1045 HWTEST_F(UIExtensionContextTest, GetFailureInfoByMessage_0100, Function | MediumTest | Level1)
1046 {
1047 std::string message = "User refused redirection";
1048 int32_t faileCode = 0;
1049 std::string failReason;
1050 int32_t resultCode = USER_CANCEL;
1051 auto context = std::make_shared<UIExtensionContext>();
1052 ASSERT_NE(context, nullptr);
1053 context->GetFailureInfoByMessage(message, faileCode, failReason, resultCode);
1054 EXPECT_EQ(faileCode, 1);
1055 EXPECT_EQ(failReason, "The user canceled this startup");
1056 resultCode = 0;
1057 context->GetFailureInfoByMessage(message, faileCode, failReason, resultCode);
1058 EXPECT_EQ(faileCode, 2);
1059 EXPECT_EQ(failReason, "User refused redirection");
1060 message = "test";
1061 context->GetFailureInfoByMessage(message, faileCode, failReason, resultCode);
1062 EXPECT_EQ(faileCode, 0);
1063 EXPECT_EQ(failReason, "A system error occurred");
1064 }
1065 } // namespace AbilityRuntime
1066 } // namespace OHOS
1067