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
31using namespace testing::ext;
32using namespace OHOS::AppExecFwk;
33namespace OHOS {
34namespace AAFwk {
35class ConfigurationTest : public testing::Test {
36public:
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
45void ConfigurationTest::SetUpTestCase(void)
46{}
47
48void ConfigurationTest::TearDownTestCase(void)
49{}
50
51void ConfigurationTest::SetUp(void)
52{}
53
54void ConfigurationTest::TearDown(void)
55{}
56
57void 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 */
86HWTEST_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 */
109HWTEST_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 */
131HWTEST_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 */
150HWTEST_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 */
181HWTEST_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 */
211HWTEST_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 */
227HWTEST_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 */
262HWTEST_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 */
295HWTEST_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 */
318HWTEST_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 */
346HWTEST_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 */
374HWTEST_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 */
407HWTEST_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 */
438HWTEST_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 */
462HWTEST_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 */
490HWTEST_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 */
548HWTEST_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 */
591HWTEST_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 */
635HWTEST_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 */
679HWTEST_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 */
714HWTEST_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 */
762HWTEST_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