1 /*
2  * Copyright (c) 2021 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 #define private public
18 #define protected public
19 #include "ability_manager_service.h"
20 #include "configuration.h"
21 #include "configuration_convertor.h"
22 #include "configuration_utils.h"
23 #include "hilog_tag_wrapper.h"
24 #ifdef SUPPORT_GRAPHICS
25 #include "locale_config.h"
26 #include "window_scene.h"
27 #endif
28 #undef private
29 #undef protected
30 
31 using namespace testing::ext;
32 using namespace OHOS::AppExecFwk;
33 namespace OHOS {
34 namespace AAFwk {
35 class ConfigurationTest : public testing::Test {
36 public:
37     static void SetUpTestCase(void);
38     static void TearDownTestCase(void);
39     void SetUp();
40     void TearDown();
41 
42     void InitResourceManager(std::shared_ptr<Global::Resource::ResourceManager> resourceManager);
43 };
44 
SetUpTestCase(void)45 void ConfigurationTest::SetUpTestCase(void)
46 {}
47 
TearDownTestCase(void)48 void ConfigurationTest::TearDownTestCase(void)
49 {}
50 
SetUp(void)51 void ConfigurationTest::SetUp(void)
52 {}
53 
TearDown(void)54 void ConfigurationTest::TearDown(void)
55 {}
56 
InitResourceManager(std::shared_ptr<Global::Resource::ResourceManager> resourceManager)57 void ConfigurationTest::InitResourceManager(std::shared_ptr<Global::Resource::ResourceManager> resourceManager)
58 {
59     std::unique_ptr<Global::Resource::ResConfig> resConfig(Global::Resource::CreateResConfig());
60     if (resConfig == nullptr) {
61         TAG_LOGE(AAFwkTag::TEST, "res config is invalid.");
62         return;
63     }
64 
65 #ifdef SUPPORT_GRAPHICS
66     UErrorCode status = U_ZERO_ERROR;
67     icu::Locale locale = icu::Locale::forLanguageTag("zh", status);
68     TAG_LOGI(AAFwkTag::TEST, "language: %{public}s, script: %{public}s, region: %{public}s",
69              locale.getLanguage(), locale.getScript(), locale.getCountry());
70     resConfig->SetLocaleInfo(locale);
71 #endif
72     Global::Resource::RState updateRet = resourceManager->UpdateResConfig(*resConfig);
73     if (updateRet != Global::Resource::RState::SUCCESS) {
74         TAG_LOGE(AAFwkTag::TEST, "Init locale failed.");
75     }
76 }
77 
78 /*
79  * Feature: Configuration
80  * Function: AddItem
81  * SubFunction: NA
82  * FunctionPoints: NA
83  * EnvConditions:NA
84  * CaseDescription: Update Configuration
85  */
HWTEST_F(ConfigurationTest, AddItem_001, TestSize.Level1)86 HWTEST_F(ConfigurationTest, AddItem_001, TestSize.Level1)
87 {
88     AppExecFwk::Configuration config;
89     config.RemoveItem(AAFwk::GlobalConfigurationKey::APP_FONT_SIZE_SCALE);
90     int displayId = 1001;
91     std::string val{ "中文" };
92     EXPECT_EQ(0, config.GetItemSize());
93     config.AddItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, val);
94     EXPECT_EQ(1, config.GetItemSize());
95 
96     // replace
97     config.AddItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, val);
98     EXPECT_EQ(1, config.GetItemSize());
99 }
100 
101 /*
102  * Feature: Configuration
103  * Function: AddItem
104  * SubFunction: NA
105  * FunctionPoints: NA
106  * EnvConditions:NA
107  * CaseDescription: Update Configuration
108  */
HWTEST_F(ConfigurationTest, AddItem_002, TestSize.Level1)109 HWTEST_F(ConfigurationTest, AddItem_002, TestSize.Level1)
110 {
111     AppExecFwk::Configuration config;
112     config.RemoveItem(AAFwk::GlobalConfigurationKey::APP_FONT_SIZE_SCALE);
113     std::string val{ "中文" };
114     EXPECT_EQ(0, config.GetItemSize());
115     config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, val);
116     EXPECT_EQ(1, config.GetItemSize());
117 
118     // replace
119     config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, val);
120     EXPECT_EQ(1, config.GetItemSize());
121 }
122 
123 /*
124  * Feature: Configuration
125  * Function: AddItem
126  * SubFunction: NA
127  * FunctionPoints: NA
128  * EnvConditions:NA
129  * CaseDescription: Update Configuration
130  */
HWTEST_F(ConfigurationTest, AddItem_003, TestSize.Level1)131 HWTEST_F(ConfigurationTest, AddItem_003, TestSize.Level1)
132 {
133     AppExecFwk::Configuration config;
134     config.RemoveItem(AAFwk::GlobalConfigurationKey::APP_FONT_SIZE_SCALE);
135     std::string val{ "中文" };
136     std::string key{ "test_key" };
137     EXPECT_EQ(0, config.GetItemSize());
138     auto ref = config.AddItem(key, val);
139     EXPECT_FALSE(ref);
140 }
141 
142 /*
143  * Feature: Configuration
144  * Function: GetItem
145  * SubFunction: NA
146  * FunctionPoints: NA
147  * EnvConditions:NA
148  * CaseDescription: Process Configuration Change
149  */
HWTEST_F(ConfigurationTest, GetItem_001, TestSize.Level1)150 HWTEST_F(ConfigurationTest, GetItem_001, TestSize.Level1)
151 {
152     AppExecFwk::Configuration config;
153     config.RemoveItem(AAFwk::GlobalConfigurationKey::APP_FONT_SIZE_SCALE);
154     int displayId = 1001;
155     std::string val{ "中文" };
156     config.AddItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, val);
157 
158     auto item = config.GetItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
159     EXPECT_EQ(item, val);
160 
161     // replace
162     std::string english{ "英文" };
163     config.AddItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, english);
164     item = config.GetItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
165     EXPECT_EQ(item, english);
166 
167     int displayId2 = 1002;
168     std::string non{ "" };
169     item = config.GetItem(displayId2, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
170     EXPECT_EQ(item, non);
171 }
172 
173 /*
174  * Feature: Configuration
175  * Function: GetItem
176  * SubFunction: NA
177  * FunctionPoints: NA
178  * EnvConditions:NA
179  * CaseDescription: Process Configuration Change
180  */
HWTEST_F(ConfigurationTest, GetItem_002, TestSize.Level1)181 HWTEST_F(ConfigurationTest, GetItem_002, TestSize.Level1)
182 {
183     AppExecFwk::Configuration config;
184     config.RemoveItem(AAFwk::GlobalConfigurationKey::APP_FONT_SIZE_SCALE);
185     std::string val{ "中文" };
186     config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, val);
187 
188     auto item = config.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
189     EXPECT_EQ(item, val);
190 
191     // replace
192     std::string english{ "英文" };
193     config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, english);
194     item = config.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
195     EXPECT_EQ(item, english);
196 
197     int displayId2 = 1002;
198     std::string non{ "" };
199     item = config.GetItem(displayId2, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
200     EXPECT_EQ(item, non);
201 }
202 
203 /*
204  * Feature: Configuration
205  * Function: GetItem
206  * SubFunction: NA
207  * FunctionPoints: NA
208  * EnvConditions:NA
209  * CaseDescription: Process Configuration Change
210  */
HWTEST_F(ConfigurationTest, GetItem_003, TestSize.Level1)211 HWTEST_F(ConfigurationTest, GetItem_003, TestSize.Level1)
212 {
213     AppExecFwk::Configuration config;
214     config.RemoveItem(AAFwk::GlobalConfigurationKey::APP_FONT_SIZE_SCALE);
215     std::string non{ "" };
216     auto item = config.GetItem("test_kay");
217     EXPECT_EQ(item, non);
218 }
219 /*
220  * Feature: Configuration
221  * Function: RemoveItem
222  * SubFunction: NA
223  * FunctionPoints: NA
224  * EnvConditions:NA
225  * CaseDescription: Process Configuration Change
226  */
HWTEST_F(ConfigurationTest, RemoveItem_001, TestSize.Level1)227 HWTEST_F(ConfigurationTest, RemoveItem_001, TestSize.Level1)
228 {
229     AppExecFwk::Configuration config;
230     config.RemoveItem(AAFwk::GlobalConfigurationKey::APP_FONT_SIZE_SCALE);
231     int displayId = 1001;
232     std::string val{ "中文" };
233     config.AddItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, val);
234 
235     auto item = config.GetItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
236     EXPECT_EQ(item, val);
237 
238     // remove it
239     bool canRemove = config.RemoveItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
240     EXPECT_TRUE(canRemove);
241 
242     std::string non{ "" };
243     item = config.GetItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
244     EXPECT_EQ(item, non);
245 
246     canRemove = config.RemoveItem(displayId, non);
247     EXPECT_FALSE(canRemove);
248 
249     int displayId2 = 1002;
250     canRemove = config.RemoveItem(displayId2, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
251     EXPECT_FALSE(canRemove);
252 }
253 
254 /*
255  * Feature: Configuration
256  * Function: RemoveItem
257  * SubFunction: NA
258  * FunctionPoints: NA
259  * EnvConditions:NA
260  * CaseDescription: Process Configuration Change
261  */
HWTEST_F(ConfigurationTest, RemoveItem_002, TestSize.Level1)262 HWTEST_F(ConfigurationTest, RemoveItem_002, TestSize.Level1)
263 {
264     AppExecFwk::Configuration config;
265     config.RemoveItem(AAFwk::GlobalConfigurationKey::APP_FONT_SIZE_SCALE);
266     std::string val{ "中文" };
267     config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, val);
268 
269     auto item = config.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
270     EXPECT_EQ(item, val);
271 
272     // remove it
273     bool canRemove = config.RemoveItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
274     EXPECT_TRUE(canRemove);
275 
276     std::string non{ "" };
277     item = config.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
278     EXPECT_EQ(item, non);
279 
280     canRemove = config.RemoveItem(non);
281     EXPECT_FALSE(canRemove);
282 
283     canRemove = config.RemoveItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
284     EXPECT_FALSE(canRemove);
285 }
286 
287 /*
288  * Feature: Configuration
289  * Function: GetItemSize
290  * SubFunction: Process Configuration Change Inner
291  * FunctionPoints: NA
292  * EnvConditions:NA
293  * CaseDescription: Process Configuration Change Inner
294  */
HWTEST_F(ConfigurationTest, GetItemSize_001, TestSize.Level1)295 HWTEST_F(ConfigurationTest, GetItemSize_001, TestSize.Level1)
296 {
297     AppExecFwk::Configuration config;
298     config.RemoveItem(AAFwk::GlobalConfigurationKey::APP_FONT_SIZE_SCALE);
299     int displayId = 1001;
300     std::string val{ "中文" };
301     EXPECT_EQ(0, config.GetItemSize());
302     config.AddItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, val);
303     EXPECT_EQ(1, config.GetItemSize());
304 
305     int displayId2 = 1002;
306     config.AddItem(displayId2, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, val);
307     EXPECT_EQ(2, config.GetItemSize());
308 }
309 
310 /*
311  * Feature: Configuration
312  * Function: CompareDifferent
313  * SubFunction: Process Configuration Change Inner
314  * FunctionPoints: NA
315  * EnvConditions:NA
316  * CaseDescription: Check according to key
317  */
HWTEST_F(ConfigurationTest, CompareDifferent_001, TestSize.Level1)318 HWTEST_F(ConfigurationTest, CompareDifferent_001, TestSize.Level1)
319 {
320     AppExecFwk::Configuration config;
321     int displayId = 1001;
322     std::string val{ "中文" };
323     config.AddItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, val);
324 
325 
326     AppExecFwk::Configuration config2;
327     int displayId2 = 1001;
328     std::string English{ "英文" };
329     config2.AddItem(displayId2, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, English);
330 
331     std::vector<std::string> changeKeyV;
332 
333     config.CompareDifferent(changeKeyV, config2);
334     int size = changeKeyV.size();
335     EXPECT_EQ(size, 1);
336 }
337 
338 /*
339  * Feature: Configuration
340  * Function: CompareDifferent
341  * SubFunction: Process Configuration Change Inner
342  * FunctionPoints: NA
343  * EnvConditions:NA
344  * CaseDescription: Check according to key
345  */
HWTEST_F(ConfigurationTest, CompareDifferent_002, TestSize.Level1)346 HWTEST_F(ConfigurationTest, CompareDifferent_002, TestSize.Level1)
347 {
348     AppExecFwk::Configuration config;
349     int displayId = 1001;
350     std::string val{ "中文" };
351     config.AddItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, val);
352 
353 
354     AppExecFwk::Configuration config2;
355     int displayId2 = 1002;
356     std::string English{ "英文" };
357     config2.AddItem(displayId2, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, English);
358 
359     std::vector<std::string> changeKeyV;
360 
361     config.CompareDifferent(changeKeyV, config2);
362     int size = changeKeyV.size();
363     EXPECT_EQ(size, 1);
364 }
365 
366 /*
367  * Feature: Configuration
368  * Function: Merge
369  * SubFunction: Process Configuration Change Inner
370  * FunctionPoints: NA
371  * EnvConditions:NA
372  * CaseDescription: Check according to key
373  */
HWTEST_F(ConfigurationTest, Merge_001, TestSize.Level1)374 HWTEST_F(ConfigurationTest, Merge_001, TestSize.Level1)
375 {
376     AppExecFwk::Configuration config;
377     int displayId = 1001;
378     std::string val{ "中文" };
379     config.AddItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, val);
380 
381 
382     AppExecFwk::Configuration config2;
383     int displayId2 = 1002;
384     std::string English{ "英文" };
385     config2.AddItem(displayId2, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, English);
386 
387     std::vector<std::string> changeKeyV;
388 
389     config.CompareDifferent(changeKeyV, config2);
390     int size = changeKeyV.size();
391     EXPECT_EQ(size, 1);
392 
393     config.Merge(changeKeyV, config2);
394 
395     auto item = config.GetItem(displayId2, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
396     EXPECT_EQ(item, English);
397 }
398 
399 /*
400  * Feature: Configuration
401  * Function: Merge
402  * SubFunction: Process Configuration Change Inner
403  * FunctionPoints: NA
404  * EnvConditions:NA
405  * CaseDescription: Check according to key
406  */
HWTEST_F(ConfigurationTest, Merge_002, TestSize.Level1)407 HWTEST_F(ConfigurationTest, Merge_002, TestSize.Level1)
408 {
409     AppExecFwk::Configuration config;
410     int displayId = 1001;
411     std::string chinese{ "Chinese " };
412     config.AddItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, chinese);
413 
414 
415     AppExecFwk::Configuration config2;
416     std::string english{ "English" };
417     config2.AddItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, english);
418 
419     std::vector<std::string> changeKeyV;
420 
421     config.CompareDifferent(changeKeyV, config2);
422     int size = changeKeyV.size();
423     EXPECT_EQ(size, 1);
424 
425     config.Merge(changeKeyV, config2);
426 
427     auto item = config.GetItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
428     EXPECT_EQ(item, english);
429 }
430 /*
431  * Feature: Configuration
432  * Function: GetName
433  * SubFunction: Process Configuration Change Inner
434  * FunctionPoints: NA
435  * EnvConditions:NA
436  * CaseDescription: Check according to key
437  */
HWTEST_F(ConfigurationTest, GetName_001, TestSize.Level1)438 HWTEST_F(ConfigurationTest, GetName_001, TestSize.Level1)
439 {
440     AppExecFwk::Configuration config;
441     int displayId = 1001;
442     std::string chinese{ "Chinese " };
443     config.AddItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, chinese);
444 
445     int displayId2 = 1002;
446     std::string english{ "English" };
447     config.AddItem(displayId2, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, english);
448 
449     auto name = config.GetName();
450     EXPECT_TRUE(name != "");
451     GTEST_LOG_(INFO) << "get name pair [" << name << "]";
452 }
453 
454 /*
455  * Feature: Configuration
456  * Function: Assignment structure
457  * SubFunction: Process Configuration Change Inner
458  * FunctionPoints: NA
459  * EnvConditions:NA
460  * CaseDescription: Check according to key
461  */
HWTEST_F(ConfigurationTest, structure_001, TestSize.Level1)462 HWTEST_F(ConfigurationTest, structure_001, TestSize.Level1)
463 {
464     AppExecFwk::Configuration config;
465     int displayId = 1001;
466     std::string chinese{ "Chinese " };
467     config.AddItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, chinese);
468 
469     AppExecFwk::Configuration configOther(config);
470     auto item = configOther.GetItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
471     EXPECT_TRUE(item == chinese);
472 
473     AppExecFwk::Configuration configThird;
474     configThird = configOther;
475 
476     auto item2 = configThird.GetItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
477     EXPECT_TRUE(item2 == chinese);
478 
479     AppExecFwk::Configuration configFourth = configThird;
480     auto item3 = configFourth.GetItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
481     EXPECT_TRUE(item3 == chinese);
482 }
483 
484 /**
485  * @tc.name: UpdateConfigToResMgr_001
486  * @tc.desc: Update configuration to resource manager.
487  * @tc.type: FUNC
488  * @tc.require: issueI6CWJD
489  */
HWTEST_F(ConfigurationTest, UpdateConfigToResMgr_001, TestSize.Level1)490 HWTEST_F(ConfigurationTest, UpdateConfigToResMgr_001, TestSize.Level1)
491 {
492     // init configuration, "en", "dark", "false"
493     AppExecFwk::Configuration configuration;
494     bool addItemRet;
495     addItemRet = configuration.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, "en");
496     EXPECT_EQ(addItemRet, true);
497     addItemRet = configuration.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE, "dark");
498     EXPECT_EQ(addItemRet, true);
499     addItemRet = configuration.AddItem(AAFwk::GlobalConfigurationKey::INPUT_POINTER_DEVICE, "false");
500     EXPECT_EQ(addItemRet, true);
501 
502     // init resource manager, "zh", "light", "true"
503     std::shared_ptr<Global::Resource::ResourceManager> resourceManager(Global::Resource::CreateResourceManager());
504     ASSERT_NE(resourceManager, nullptr);
505     std::unique_ptr<Global::Resource::ResConfig> resConfig(Global::Resource::CreateResConfig());
506     ASSERT_NE(resConfig, nullptr);
507 
508 #ifdef SUPPORT_GRAPHICS
509     UErrorCode status = U_ZERO_ERROR;
510     icu::Locale locale = icu::Locale::forLanguageTag("zh", status);
511     EXPECT_EQ(status, U_ZERO_ERROR);
512     TAG_LOGI(AAFwkTag::TEST, "language: %{public}s, script: %{public}s, region: %{public}s",
513              locale.getLanguage(), locale.getScript(), locale.getCountry());
514     resConfig->SetLocaleInfo(locale);
515 #endif
516     resConfig->SetColorMode(ConvertColorMode("light"));
517     resConfig->SetInputDevice(ConvertHasPointerDevice("true"));
518     Global::Resource::RState updateRet = resourceManager->UpdateResConfig(*resConfig);
519     EXPECT_EQ(updateRet, Global::Resource::RState::SUCCESS);
520 
521     // update configuration to resource manager
522     auto configUtils = std::make_shared<AbilityRuntime::ConfigurationUtils>();
523     ASSERT_NE(configUtils, nullptr);
524     configUtils->UpdateGlobalConfig(configuration, nullptr);
525     configUtils->UpdateGlobalConfig(configuration, resourceManager);
526 
527     // check resource manager has updated to "en", "dark", "false"
528     std::unique_ptr<Global::Resource::ResConfig> updatedResConfig(Global::Resource::CreateResConfig());
529     ASSERT_NE(updatedResConfig, nullptr);
530     resourceManager->GetResConfig(*updatedResConfig);
531 #ifdef SUPPORT_GRAPHICS
532     const icu::Locale *localeInfo = updatedResConfig->GetLocaleInfo();
533     ASSERT_NE(localeInfo, nullptr);
534     TAG_LOGI(AAFwkTag::TEST, "language: %{public}s, script: %{public}s, region: %{public}s",
535              localeInfo->getLanguage(), localeInfo->getScript(), localeInfo->getCountry());
536     EXPECT_EQ(strcmp(localeInfo->getLanguage(), "en"), 0);
537 #endif
538     EXPECT_EQ(updatedResConfig->GetColorMode(), ConvertColorMode("dark"));
539     EXPECT_EQ(updatedResConfig->GetInputDevice(), ConvertHasPointerDevice("false"));
540 }
541 
542 /**
543  * @tc.name: InitDisplayConfig_0100
544  * @tc.desc: Init display config.
545  * @tc.type: FUNC
546  * @tc.require: issueI7HPHB
547  */
HWTEST_F(ConfigurationTest, InitDisplayConfig_0100, TestSize.Level1)548 HWTEST_F(ConfigurationTest, InitDisplayConfig_0100, TestSize.Level1)
549 {
550     auto configUtils = std::make_shared<AbilityRuntime::ConfigurationUtils>();
551     ASSERT_NE(configUtils, nullptr);
552 
553     int displayId = Rosen::WindowScene::DEFAULT_DISPLAY_ID;
554     float originDensity;
555     std::string originDirection;
556     auto ret = configUtils->GetDisplayConfig(displayId, originDensity, originDirection);
557     EXPECT_EQ(ret, true);
558 
559     configUtils->InitDisplayConfig(displayId, nullptr, nullptr);
560 
561     AppExecFwk::Configuration originConfig;
562     auto configuration = std::make_shared<Configuration>(originConfig);
563     ASSERT_NE(configuration, nullptr);
564     configUtils->InitDisplayConfig(displayId, configuration, nullptr);
565 
566     std::shared_ptr<Global::Resource::ResourceManager> resourceManager(Global::Resource::CreateResourceManager());
567     ASSERT_NE(resourceManager, nullptr);
568     InitResourceManager(resourceManager);
569     configUtils->InitDisplayConfig(displayId, configuration, resourceManager);
570 
571     // check configurtion
572     std::string displayIdStr = configuration->GetItem(ConfigurationInner::APPLICATION_DISPLAYID);
573     EXPECT_EQ(displayIdStr, std::to_string(displayId));
574     std::string densityStr = configuration->GetItem(displayId, ConfigurationInner::APPLICATION_DENSITYDPI);
575     EXPECT_EQ(densityStr, GetDensityStr(originDensity));
576     std::string directionStr = configuration->GetItem(displayId, ConfigurationInner::APPLICATION_DIRECTION);
577     EXPECT_EQ(directionStr, originDirection);
578 
579     // check resourcemanager
580     std::unique_ptr<Global::Resource::ResConfig> resConfig(Global::Resource::CreateResConfig());
581     resourceManager->GetResConfig(*resConfig);
582     EXPECT_EQ(originDensity, resConfig->GetScreenDensity());
583     EXPECT_EQ(ConvertDirection(originDirection), resConfig->GetDirection());
584 }
585 
586 /**
587  * @tc.name: InitDisplayConfig_0200
588  * @tc.desc: Init display config.
589  * @tc.type: FUNC
590  */
HWTEST_F(ConfigurationTest, InitDisplayConfig_0200, TestSize.Level1)591 HWTEST_F(ConfigurationTest, InitDisplayConfig_0200, TestSize.Level1)
592 {
593     auto configUtils = std::make_shared<AbilityRuntime::ConfigurationUtils>();
594     ASSERT_NE(configUtils, nullptr);
595 
596     int displayId = Rosen::WindowScene::DEFAULT_DISPLAY_ID;
597     float originDensity;
598     std::string originDirection;
599     auto ret = configUtils->GetDisplayConfig(displayId, originDensity, originDirection);
600     EXPECT_EQ(ret, true);
601 
602     configUtils->InitDisplayConfig(nullptr, nullptr, displayId, originDensity, 0);
603 
604     AppExecFwk::Configuration originConfig;
605     auto configuration = std::make_shared<Configuration>(originConfig);
606     ASSERT_NE(configuration, nullptr);
607     configUtils->InitDisplayConfig(configuration, nullptr, displayId, originDensity, 0);
608 
609     std::shared_ptr<Global::Resource::ResourceManager> resourceManager(Global::Resource::CreateResourceManager());
610     ASSERT_NE(resourceManager, nullptr);
611     InitResourceManager(resourceManager);
612     configUtils->InitDisplayConfig(configuration, resourceManager, displayId, originDensity, 0);
613 
614     // check configurtion
615     std::string displayIdStr = configuration->GetItem(ConfigurationInner::APPLICATION_DISPLAYID);
616     EXPECT_EQ(displayIdStr, std::to_string(displayId));
617     std::string densityStr = configuration->GetItem(displayId, ConfigurationInner::APPLICATION_DENSITYDPI);
618     EXPECT_EQ(densityStr, GetDensityStr(originDensity));
619     std::string directionStr = configuration->GetItem(displayId, ConfigurationInner::APPLICATION_DIRECTION);
620     EXPECT_EQ(directionStr, ConfigurationInner::DIRECTION_VERTICAL);
621 
622     // check resourcemanager
623     std::unique_ptr<Global::Resource::ResConfig> resConfig(Global::Resource::CreateResConfig());
624     resourceManager->GetResConfig(*resConfig);
625     EXPECT_EQ(originDensity, resConfig->GetScreenDensity());
626     EXPECT_EQ(ConvertDirection(ConfigurationInner::DIRECTION_VERTICAL), resConfig->GetDirection());
627 }
628 
629 /**
630  * @tc.name: UpdateDisplayConfig_0100
631  * @tc.desc: Update display config with changed config.
632  * @tc.type: FUNC
633  * @tc.require: issueI7HPHB
634  */
HWTEST_F(ConfigurationTest, UpdateDisplayConfig_0100, TestSize.Level1)635 HWTEST_F(ConfigurationTest, UpdateDisplayConfig_0100, TestSize.Level1)
636 {
637     auto configUtils = std::make_shared<AbilityRuntime::ConfigurationUtils>();
638     ASSERT_NE(configUtils, nullptr);
639 
640     int displayId = Rosen::WindowScene::DEFAULT_DISPLAY_ID;
641     float originDensity;
642     std::string originDirection;
643     auto ret = configUtils->GetDisplayConfig(displayId, originDensity, originDirection);
644     EXPECT_EQ(ret, true);
645 
646     bool configChanged;
647     configUtils->UpdateDisplayConfig(displayId, nullptr, nullptr, configChanged);
648 
649     AppExecFwk::Configuration originConfig;
650     auto configuration = std::make_shared<Configuration>(originConfig);
651     ASSERT_NE(configuration, nullptr);
652     configUtils->UpdateDisplayConfig(displayId, configuration, nullptr, configChanged);
653 
654     std::shared_ptr<Global::Resource::ResourceManager> resourceManager(Global::Resource::CreateResourceManager());
655     ASSERT_NE(resourceManager, nullptr);
656     InitResourceManager(resourceManager);
657     configUtils->UpdateDisplayConfig(displayId, configuration, resourceManager, configChanged);
658     EXPECT_EQ(configChanged, true);
659 
660     // check configurtion
661     std::string densityStr = configuration->GetItem(displayId, ConfigurationInner::APPLICATION_DENSITYDPI);
662     EXPECT_EQ(densityStr, GetDensityStr(originDensity));
663     std::string directionStr = configuration->GetItem(displayId, ConfigurationInner::APPLICATION_DIRECTION);
664     EXPECT_EQ(directionStr, originDirection);
665 
666     // check resourcemanager
667     std::unique_ptr<Global::Resource::ResConfig> resConfig(Global::Resource::CreateResConfig());
668     resourceManager->GetResConfig(*resConfig);
669     EXPECT_EQ(originDensity, resConfig->GetScreenDensity());
670     EXPECT_EQ(ConvertDirection(originDirection), resConfig->GetDirection());
671 }
672 
673 /**
674  * @tc.name: UpdateDisplayConfig_0200
675  * @tc.desc: Update display config with unchanged config.
676  * @tc.type: FUNC
677  * @tc.require: issueI7HPHB
678  */
HWTEST_F(ConfigurationTest, UpdateDisplayConfig_0200, TestSize.Level1)679 HWTEST_F(ConfigurationTest, UpdateDisplayConfig_0200, TestSize.Level1)
680 {
681     auto configUtils = std::make_shared<AbilityRuntime::ConfigurationUtils>();
682     ASSERT_NE(configUtils, nullptr);
683 
684     int displayId = Rosen::WindowScene::DEFAULT_DISPLAY_ID;
685     float originDensity;
686     std::string originDirection;
687     auto ret = configUtils->GetDisplayConfig(displayId, originDensity, originDirection);
688     EXPECT_EQ(ret, true);
689 
690     bool configChanged;
691     configUtils->UpdateDisplayConfig(displayId, nullptr, nullptr, configChanged);
692 
693     AppExecFwk::Configuration originConfig;
694     auto configuration = std::make_shared<Configuration>(originConfig);
695     ASSERT_NE(configuration, nullptr);
696     configUtils->UpdateDisplayConfig(displayId, configuration, nullptr, configChanged);
697 
698     // Add configuration.
699     configuration->AddItem(displayId, ConfigurationInner::APPLICATION_DENSITYDPI, GetDensityStr(originDensity));
700     configuration->AddItem(displayId, ConfigurationInner::APPLICATION_DIRECTION, originDirection);
701     configuration->AddItem(ConfigurationInner::APPLICATION_DISPLAYID, std::to_string(displayId));
702 
703     std::shared_ptr<Global::Resource::ResourceManager> resourceManager(Global::Resource::CreateResourceManager());
704     ASSERT_NE(resourceManager, nullptr);
705     configUtils->UpdateDisplayConfig(displayId, configuration, resourceManager, configChanged);
706     EXPECT_EQ(configChanged, false);
707 }
708 
709 /**
710  * @tc.name: UpdateDisplayConfig_0300
711  * @tc.desc: Update display config with changed config.
712  * @tc.type: FUNC
713  */
HWTEST_F(ConfigurationTest, UpdateDisplayConfig_0300, TestSize.Level1)714 HWTEST_F(ConfigurationTest, UpdateDisplayConfig_0300, TestSize.Level1)
715 {
716     auto configUtils = std::make_shared<AbilityRuntime::ConfigurationUtils>();
717     ASSERT_NE(configUtils, nullptr);
718 
719     int displayId = Rosen::WindowScene::DEFAULT_DISPLAY_ID;
720     float originDensity;
721     std::string originDirection;
722     auto ret = configUtils->GetDisplayConfig(displayId, originDensity, originDirection);
723     EXPECT_EQ(ret, true);
724 
725     bool configChanged = false;
726     configChanged = configUtils->UpdateDisplayConfig(
727         nullptr, nullptr, displayId, originDensity, Rosen::DisplayOrientation::PORTRAIT);
728     EXPECT_EQ(configChanged, false);
729 
730     AppExecFwk::Configuration originConfig;
731     auto configuration = std::make_shared<Configuration>(originConfig);
732     ASSERT_NE(configuration, nullptr);
733     configChanged = configUtils->UpdateDisplayConfig(
734         configuration, nullptr, displayId, originDensity, Rosen::DisplayOrientation::PORTRAIT);
735     EXPECT_EQ(configChanged, false);
736 
737     std::shared_ptr<Global::Resource::ResourceManager> resourceManager(Global::Resource::CreateResourceManager());
738     ASSERT_NE(resourceManager, nullptr);
739     InitResourceManager(resourceManager);
740     configChanged = configUtils->UpdateDisplayConfig(
741         configuration, resourceManager, displayId, originDensity, Rosen::DisplayOrientation::PORTRAIT);
742     EXPECT_EQ(configChanged, true);
743 
744     // check configurtion
745     std::string densityStr = configuration->GetItem(displayId, ConfigurationInner::APPLICATION_DENSITYDPI);
746     EXPECT_EQ(densityStr, GetDensityStr(originDensity));
747     std::string directionStr = configuration->GetItem(displayId, ConfigurationInner::APPLICATION_DIRECTION);
748     EXPECT_EQ(directionStr, ConfigurationInner::DIRECTION_VERTICAL);
749 
750     // check resourcemanager
751     std::unique_ptr<Global::Resource::ResConfig> resConfig(Global::Resource::CreateResConfig());
752     resourceManager->GetResConfig(*resConfig);
753     EXPECT_EQ(originDensity, resConfig->GetScreenDensity());
754     EXPECT_EQ(ConvertDirection(ConfigurationInner::DIRECTION_VERTICAL), resConfig->GetDirection());
755 }
756 
757 /**
758  * @tc.name: UpdateDisplayConfig_0400
759  * @tc.desc: Update display config with unchanged config.
760  * @tc.type: FUNC
761  */
HWTEST_F(ConfigurationTest, UpdateDisplayConfig_0400, TestSize.Level1)762 HWTEST_F(ConfigurationTest, UpdateDisplayConfig_0400, TestSize.Level1)
763 {
764     auto configUtils = std::make_shared<AbilityRuntime::ConfigurationUtils>();
765     ASSERT_NE(configUtils, nullptr);
766 
767     int displayId = Rosen::WindowScene::DEFAULT_DISPLAY_ID;
768     float originDensity;
769     std::string originDirection;
770     auto ret = configUtils->GetDisplayConfig(displayId, originDensity, originDirection);
771     EXPECT_EQ(ret, true);
772 
773     AppExecFwk::Configuration originConfig;
774     auto configuration = std::make_shared<Configuration>(originConfig);
775     ASSERT_NE(configuration, nullptr);
776 
777     // Add configuration.
778     configuration->AddItem(displayId, ConfigurationInner::APPLICATION_DENSITYDPI, GetDensityStr(originDensity));
779     configuration->AddItem(
780         displayId, ConfigurationInner::APPLICATION_DIRECTION, ConfigurationInner::DIRECTION_VERTICAL);
781     configuration->AddItem(ConfigurationInner::APPLICATION_DISPLAYID, std::to_string(displayId));
782 
783     std::shared_ptr<Global::Resource::ResourceManager> resourceManager(Global::Resource::CreateResourceManager());
784     ASSERT_NE(resourceManager, nullptr);
785     bool configChanged = configUtils->UpdateDisplayConfig(
786         configuration, resourceManager, displayId, originDensity, Rosen::DisplayOrientation::PORTRAIT);
787     EXPECT_EQ(configChanged, false);
788 }
789 } // namespace AAFwk
790 } // namespace OHOS
791