1 /*
2 * Copyright (c) 2024 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 #include "ability.h"
19 #include "ability_local_record.h"
20 #include "ability_record_mgr.h"
21 #include "ability_stage.h"
22 #include "application_context.h"
23 #include "application_impl.h"
24 #include "application_info.h"
25 #include "configuration.h"
26 #include "context_deal.h"
27 #include "context_impl.h"
28 #include "fa_ability_thread.h"
29 #include "hap_module_info.h"
30 #include "hilog_tag_wrapper.h"
31 #include "mock_i_remote_object.h"
32 #include "mock_runtime.h"
33 #include "ohos_application.h"
34 #include "pac_map.h"
35 #include "process_info.h"
36 #include "resource_manager.h"
37 #include "runtime.h"
38 #include "ui_ability.h"
39 #undef private
40 #include <unordered_map>
41
42 using namespace testing;
43 using namespace testing::ext;
44 using namespace OHOS::AbilityRuntime;
45
46 namespace OHOS {
47 namespace AppExecFwk {
48 class OHOSApplicationFirstTest : public testing::Test {
49 public:
50 static void SetUpTestCase();
51 static void TearDownTestCase();
52 void SetUp() override;
53 void TearDown() override;
54 std::shared_ptr<OHOSApplication> ohosApplication_;
55 std::unordered_map<std::string, std::shared_ptr<AbilityRuntime::AbilityStage>> abilityStages_;
56 };
57
SetUpTestCase(void)58 void OHOSApplicationFirstTest::SetUpTestCase(void)
59 {}
60
TearDownTestCase(void)61 void OHOSApplicationFirstTest::TearDownTestCase(void)
62 {}
63
SetUp()64 void OHOSApplicationFirstTest::SetUp()
65 {
66 ohosApplication_ = std::make_shared<OHOSApplication>();
67 }
68
TearDown()69 void OHOSApplicationFirstTest::TearDown()
70 {
71 ohosApplication_ = nullptr;
72 }
73
74 /*
75 * @tc.number: AppExecFwk_OHOSApplicationFirstTest_CleanEmptyAbilityStage_0100
76 * @tc.name: CleanEmptyAbilityStage
77 * @tc.desc: Test when all abilityStages are nullptr then the map should be empty.
78 */
79 HWTEST_F(OHOSApplicationFirstTest, CleanEmptyAbilityStage_0100, TestSize.Level0)
80 {
81 TAG_LOGI(AAFwkTag::TEST, "CleanEmptyAbilityStage_0100 start");
82 ohosApplication_->abilityStages_ = abilityStages_;
83 ohosApplication_->CleanEmptyAbilityStage();
84 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
85 TAG_LOGI(AAFwkTag::TEST, "CleanEmptyAbilityStage_0100 end");
86 }
87
88 /*
89 * @tc.number: AppExecFwk_OHOSApplicationFirstTest_CleanEmptyAbilityStage_0200
90 * @tc.name: CleanEmptyAbilityStage
91 * @tc.desc: Test when some abilityStages are not nullptr then the map should not be empty.
92 */
93 HWTEST_F(OHOSApplicationFirstTest, CleanEmptyAbilityStage_0200, TestSize.Level0)
94 {
95 TAG_LOGI(AAFwkTag::TEST, "CleanEmptyAbilityStage_0200 start");
96 AppExecFwk::HapModuleInfo info;
97 AbilityRuntime::Runtime::Options options;
98 auto runTime = AbilityRuntime::Runtime::Create(options);
99 abilityStages_.emplace("1", AbilityRuntime::AbilityStage::Create(runTime, info));
100 abilityStages_.emplace("2", AbilityRuntime::AbilityStage::Create(runTime, info));
101 abilityStages_.emplace("3", AbilityRuntime::AbilityStage::Create(runTime, info));
102 ohosApplication_->abilityStages_ = abilityStages_;
103 EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
104 ohosApplication_->CleanEmptyAbilityStage();
105 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
106 TAG_LOGI(AAFwkTag::TEST, "CleanEmptyAbilityStage_0200 end");
107 }
108
109 /*
110 * @tc.number: AppExecFwk_OHOSApplicationFirstTest_CleanEmptyAbilityStage_0300
111 * @tc.name: CleanEmptyAbilityStage
112 * @tc.desc: Test when all abilityStages are non-empty then the map should not be empty.
113 */
114 HWTEST_F(OHOSApplicationFirstTest, CleanEmptyAbilityStage_0300, TestSize.Level0)
115 {
116 TAG_LOGI(AAFwkTag::TEST, "CleanEmptyAbilityStage_0300 start");
117 AppExecFwk::HapModuleInfo info;
118 AbilityRuntime::Runtime::Options options;
119 auto runTime = AbilityRuntime::Runtime::Create(options);
120 abilityStages_["1"] = nullptr;
121 abilityStages_["2"] = nullptr;
122 abilityStages_["3"] = nullptr;
123 for (auto &it : abilityStages_) {
124 it.second = AbilityRuntime::AbilityStage::Create(runTime, info);
125 }
126 ohosApplication_->abilityStages_ = abilityStages_;
127 EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
128 ohosApplication_->CleanEmptyAbilityStage();
129 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
130 TAG_LOGI(AAFwkTag::TEST, "CleanEmptyAbilityStage_0300 end");
131 }
132
133 /*
134 * @tc.number: AppExecFwk_OHOSApplicationFirstTest_IsUpdateColorNeeded_0100
135 * @tc.name: IsUpdateColorNeeded
136 * @tc.desc: Test when all conditions are met, IsUpdateColorNeeded should return false.
137 */
138 HWTEST_F(OHOSApplicationFirstTest, IsUpdateColorNeeded_0100, TestSize.Level0)
139 {
140 TAG_LOGI(AAFwkTag::TEST, "IsUpdateColorNeeded_0100 start");
141 Configuration config;
142 std::string colorMode = "light";
143 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE, colorMode);
144 auto colorMode1 = config.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE);
145 AbilityRuntime::SetLevel level = AbilityRuntime::SetLevel::Application;
146 AbilityRuntime::ApplicationConfigurationManager::GetInstance().SetColorModeSetLevel(level, colorMode1);
147 AbilityRuntime::SetLevel level1 = AbilityRuntime::SetLevel::System;
148 std::string colorModeIsSetBySa =
149 config.GetItem(AAFwk::GlobalConfigurationKey::COLORMODE_IS_SET_BY_SA);
150 bool result = ohosApplication_->IsUpdateColorNeeded(config, level1);
151 if (level1 < AbilityRuntime::SetLevel::SA && !colorModeIsSetBySa.empty()) {
152 level1 = AbilityRuntime::SetLevel::SA;
153 }
154 auto colorLevel =
155 static_cast<uint8_t>(AbilityRuntime::ApplicationConfigurationManager::GetInstance().GetColorModeSetLevel());
156 TAG_LOGI(AAFwkTag::TEST, "colorLevel = %{public}d", colorLevel);
157 EXPECT_TRUE(level1 < AbilityRuntime::ApplicationConfigurationManager::GetInstance().GetColorModeSetLevel());
158 EXPECT_FALSE(colorMode1.empty());
159 EXPECT_FALSE(result);
160 TAG_LOGI(AAFwkTag::TEST, "IsUpdateColorNeeded_0100 end");
161 }
162
163 /*
164 * @tc.number: AppExecFwk_OHOSApplicationFirstTest_IsUpdateColorNeeded_0200
165 * @tc.name: IsUpdateColorNeeded
166 * @tc.desc: Test when all conditions are met, IsUpdateColorNeeded should return true.
167 */
168 HWTEST_F(OHOSApplicationFirstTest, IsUpdateColorNeeded_0200, TestSize.Level0)
169 {
170 TAG_LOGI(AAFwkTag::TEST, "IsUpdateColorNeeded_0200 start");
171 Configuration config;
172 std::string colorMode = "auto";
173 ohosApplication_->configuration_ = std::make_shared<Configuration>();
174 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE, colorMode);
175 std::string colorMode1 = config.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE);
176 EXPECT_FALSE(colorMode1.empty());
177 AbilityRuntime::SetLevel level = AbilityRuntime::SetLevel::Application;
178 bool result = ohosApplication_->IsUpdateColorNeeded(config, level);
179 EXPECT_TRUE(result);
180 TAG_LOGI(AAFwkTag::TEST, "IsUpdateColorNeeded_0200 end");
181 }
182
183 /*
184 * @tc.number: AppExecFwk_OHOSApplicationFirstTest_IsUpdateLanguageNeeded_0100
185 * @tc.name: IsUpdateLanguageNeeded
186 * @tc.desc: Test IsUpdateLanguageNeeded should return true.
187 */
188 HWTEST_F(OHOSApplicationFirstTest, IsUpdateLanguageNeeded_0100, TestSize.Level0)
189 {
190 TAG_LOGI(AAFwkTag::TEST, "IsUpdateLanguageNeeded_0100 start");
191 Configuration config;
192 AbilityRuntime::SetLevel level = AbilityRuntime::SetLevel::Application;
193 AbilityRuntime::ApplicationConfigurationManager::GetInstance().SetLanguageSetLevel(level);
194 std::string testLanguge = "ch-zh";
195 ohosApplication_->configuration_ = std::make_shared<Configuration>();
196 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, testLanguge);
197 std::string language = config.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
198 EXPECT_FALSE(language.empty());
199 bool result = ohosApplication_->IsUpdateLanguageNeeded(config, level);
200 EXPECT_TRUE(result);
201 TAG_LOGI(AAFwkTag::TEST, "IsUpdateLanguageNeeded_0100 end");
202 }
203
204 /*
205 * @tc.number: AppExecFwk_OHOSApplicationFirstTest_IsUpdateLanguageNeeded_0200
206 * @tc.name: IsUpdateLanguageNeeded
207 * @tc.desc: Test IsUpdateLanguageNeeded should return false.
208 */
209 HWTEST_F(OHOSApplicationFirstTest, IsUpdateLanguageNeeded_0200, TestSize.Level0)
210 {
211 TAG_LOGI(AAFwkTag::TEST, "IsUpdateLanguageNeeded_0200 start");
212 Configuration config;
213 AbilityRuntime::SetLevel level = AbilityRuntime::SetLevel::Application;
214 AbilityRuntime::ApplicationConfigurationManager::GetInstance().SetLanguageSetLevel(level);
215 ohosApplication_->configuration_ = std::make_shared<Configuration>();
216 std::string language = config.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
217 bool result = ohosApplication_->IsUpdateLanguageNeeded(config, level);
218 EXPECT_TRUE(language.empty());
219 EXPECT_FALSE(result);
220 TAG_LOGI(AAFwkTag::TEST, "IsUpdateLanguageNeeded_0200 end");
221 }
222
223 /*
224 * @tc.number: AppExecFwk_OHOSApplicationFirstTest_IsUpdateLanguageNeeded_0300
225 * @tc.name: IsUpdateLanguageNeeded
226 * @tc.desc: Test IsUpdateLanguageNeeded should return false.
227 */
228 HWTEST_F(OHOSApplicationFirstTest, IsUpdateLanguageNeeded_0300, TestSize.Level0)
229 {
230 TAG_LOGI(AAFwkTag::TEST, "IsUpdateLanguageNeeded_0300 start");
231 Configuration config;
232 AbilityRuntime::SetLevel level = AbilityRuntime::SetLevel::Application;
233 AbilityRuntime::SetLevel testLevel = AbilityRuntime::SetLevel::System;
234 AbilityRuntime::ApplicationConfigurationManager::GetInstance().SetLanguageSetLevel(level);
235 std::string testLanguge = "ch-zh";
236 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, testLanguge);
237 ohosApplication_->configuration_ = std::make_shared<Configuration>();
238 std::string language = config.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
239 bool result = ohosApplication_->IsUpdateLanguageNeeded(config, testLevel);
240 EXPECT_FALSE(language.empty());
241 EXPECT_FALSE(level < AbilityRuntime::ApplicationConfigurationManager::GetInstance().GetLanguageSetLevel());
242 EXPECT_FALSE(result);
243 TAG_LOGI(AAFwkTag::TEST, "IsUpdateLanguageNeeded_0300 end");
244 }
245
246 /*
247 * @tc.number: AppExecFwk_OHOSApplicationFirstTest_IsMainProcess_0100
248 * @tc.name: IsMainProcess
249 * @tc.desc: Test when processType is not NORMAL then IsMainProcess returns false.
250 */
251 HWTEST_F(OHOSApplicationFirstTest, IsMainProcess_0100, TestSize.Level0)
252 {
253 TAG_LOGI(AAFwkTag::TEST, "IsMainProcess_0100 start");
254 auto info = std::make_shared<ProcessInfo>("testProcess", 10);
255 info->SetProcessType(ProcessType::EXTENSION);
256 ohosApplication_->SetProcessInfo(info);
257 auto res = ohosApplication_->IsMainProcess("testBundleName", "testProcess");
258 auto processInfo = ohosApplication_->GetProcessInfo();
259 std::string processName = processInfo->GetProcessName();
260 EXPECT_EQ(processName, "testProcess");
261 EXPECT_TRUE(res);
262 TAG_LOGI(AAFwkTag::TEST, "IsMainProcess_0100 end");
263 }
264
265 /*
266 * @tc.number: AppExecFwk_OHOSApplicationFirstTest_IsMainProcess_0200
267 * @tc.name: IsMainProcess
268 * @tc.desc: Test when processType is not NORMAL then IsMainProcess returns false.
269 */
270 HWTEST_F(OHOSApplicationFirstTest, IsMainProcess_0200, TestSize.Level0)
271 {
272 TAG_LOGI(AAFwkTag::TEST, "IsMainProcess_0200 start");
273 auto info = std::make_shared<ProcessInfo>("testProcess", 10);
274 info->SetProcessType(ProcessType::EXTENSION);
275 ohosApplication_->SetProcessInfo(info);
276 auto res = ohosApplication_->IsMainProcess("testBundleName", "testProcess");
277 auto processInfo = ohosApplication_->GetProcessInfo();
278 ProcessType processType = processInfo->GetProcessType();
279 EXPECT_NE(processType, ProcessType::NORMAL);
280 EXPECT_TRUE(res);
281 TAG_LOGI(AAFwkTag::TEST, "IsMainProcess_0200 end");
282 }
283
284 /*
285 * @tc.number: AppExecFwk_OHOSApplicationFirstTest_IsMainProcess_0300
286 * @tc.name: IsMainProcess
287 * @tc.desc: Test when processType is NORMAL then IsMainProcess returns true.
288 */
289 HWTEST_F(OHOSApplicationFirstTest, IsMainProcess_0300, TestSize.Level0)
290 {
291 TAG_LOGI(AAFwkTag::TEST, "IsMainProcess_0300 start");
292 auto info = std::make_shared<ProcessInfo>("testProcess", 10);
293 ohosApplication_->SetProcessInfo(info);
294 auto res = ohosApplication_->IsMainProcess("testBundleName", "testProcess");
295 auto processInfo = ohosApplication_->GetProcessInfo();
296 ProcessType processType = processInfo->GetProcessType();
297 EXPECT_EQ(processType, ProcessType::NORMAL);
298 EXPECT_TRUE(res);
299 TAG_LOGI(AAFwkTag::TEST, "IsMainProcess_0300 end");
300 }
301
302 /*
303 * @tc.number: AppExecFwk_OHOSApplicationFirstTest_IsMainProcess_0400
304 * @tc.name: IsMainProcess
305 * @tc.desc: Test when none of the processInfo are met then IsMainProcess returns false.
306 */
307 HWTEST_F(OHOSApplicationFirstTest, IsMainProcess_0400, TestSize.Level0)
308 {
309 TAG_LOGI(AAFwkTag::TEST, "IsMainProcess_0400 start");
310 auto info = std::make_shared<ProcessInfo>("testProcess", 10);
311 ohosApplication_->SetProcessInfo(info);
312 auto res = ohosApplication_->IsMainProcess("testBundleName", "testProcess");
313 auto processInfo = ohosApplication_->GetProcessInfo();
314 EXPECT_TRUE(res);
315 EXPECT_NE(processInfo, nullptr);
316 TAG_LOGI(AAFwkTag::TEST, "IsMainProcess_0400 end");
317 }
318
319 /*
320 * @tc.number: AppExecFwk_OHOSApplicationFirstTest_IsMainProcess_0500
321 * @tc.name: IsMainProcess
322 * @tc.desc: Test when processInfo is not nullptr then IsMainProcess returns.
323 */
324 HWTEST_F(OHOSApplicationFirstTest, IsMainProcess_0500, TestSize.Level0)
325 {
326 TAG_LOGI(AAFwkTag::TEST, "IsMainProcess_0500 start");
327 auto res = ohosApplication_->IsMainProcess("testBundleName", "testProcess");
328 auto processInfo = ohosApplication_->GetProcessInfo();
329 EXPECT_FALSE(res);
330 EXPECT_EQ(processInfo, nullptr);
331 TAG_LOGI(AAFwkTag::TEST, "IsMainProcess_0500 end");
332 }
333
334 /*
335 * @tc.number: AppExecFwk_OHOSApplicationFirstTest_UpdateAppContextResMgr_0100
336 * @tc.name: UpdateAppContextResMgr
337 * @tc.desc: Test when context is nullptr then UpdateAppContextResMgr returns.
338 */
339 HWTEST_F(OHOSApplicationFirstTest, UpdateAppContextResMgr_0100, TestSize.Level0)
340 {
341 TAG_LOGI(AAFwkTag::TEST, "UpdateAppContextResMgr_0100 start");
342 Configuration config;
343 auto context = ohosApplication_->GetAppContext();
344 ohosApplication_->UpdateAppContextResMgr(config);
345 EXPECT_EQ(context, nullptr);
346 TAG_LOGI(AAFwkTag::TEST, "UpdateAppContextResMgr_0100 end");
347 }
348
349 /*
350 * @tc.number: AppExecFwk_OHOSApplicationFirstTest_UpdateAppContextResMgr_0200
351 * @tc.name: UpdateAppContextResMgr
352 * @tc.desc: Test when context is not nullptr then UpdateAppContextResMgr updates the global config.
353 */
354 HWTEST_F(OHOSApplicationFirstTest, UpdateAppContextResMgr_0200, TestSize.Level0)
355 {
356 TAG_LOGI(AAFwkTag::TEST, "UpdateAppContextResMgr_0200 start");
357 Configuration config;
358 auto instance = AbilityRuntime::ApplicationContext::GetInstance();
359 ohosApplication_->abilityRuntimeContext_ = instance;
360 auto context = ohosApplication_->GetAppContext();
361 ohosApplication_->UpdateAppContextResMgr(config);
362 EXPECT_NE(context, nullptr);
363 TAG_LOGI(AAFwkTag::TEST, "UpdateAppContextResMgr_0200 end");
364 }
365
366 /*
367 * @tc.number: AppExecFwk_OHOSApplicationFirstTest_OnConfigurationUpdated_0100
368 * @tc.name: OnConfigurationUpdated
369 * @tc.desc: Verify function OnConfigurationUpdated pointer abilityRecordMgr_ empty
370 */
371 HWTEST_F(OHOSApplicationFirstTest, OnConfigurationUpdated_0100, TestSize.Level1)
372 {
373 TAG_LOGI(AAFwkTag::TEST, "OnConfigurationUpdated_0100 start");
374 Configuration config;
375 AbilityRuntime::SetLevel level = AbilityRuntime::SetLevel::System;
376 ohosApplication_->OnConfigurationUpdated(config, level);
377 EXPECT_TRUE(ohosApplication_->abilityRecordMgr_ == nullptr);
378 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
379 ohosApplication_->OnConfigurationUpdated(config, level);
380 EXPECT_TRUE(ohosApplication_->configuration_ == nullptr);
381 EXPECT_TRUE(ohosApplication_->abilityRuntimeContext_ == nullptr);
382 TAG_LOGI(AAFwkTag::TEST, "OnConfigurationUpdated_0100 end");
383 }
384
385 /*
386 * @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200
387 * @tc.name: OnConfigurationUpdated
388 * @tc.desc: Verify function OnConfigurationUpdated pointer abilityRecord not empty
389 */
390 HWTEST_F(OHOSApplicationFirstTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200, TestSize.Level1)
391 {
392 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200 start.";
393 Configuration config;
394 AbilityRuntime::SetLevel level = AbilityRuntime::SetLevel::System;
395 ohosApplication_->abilityRuntimeContext_ = AbilityRuntime::ApplicationContext::GetInstance();
396 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, "zh_CN");
397 config.AddItem(AAFwk::GlobalConfigurationKey::COLORMODE_IS_SET_BY_APP, "value");
398 config.AddItem(AAFwk::GlobalConfigurationKey::COLORMODE_IS_SET_BY_SA, "value");
399 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
400 ohosApplication_->configuration_ = std::make_shared<Configuration>();
401 ohosApplication_->configuration_->AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE, "value");
402 ohosApplication_->configuration_->AddItem(AAFwk::GlobalConfigurationKey::COLORMODE_IS_SET_BY_APP, "value");
403 ohosApplication_->configuration_->AddItem(AAFwk::GlobalConfigurationKey::COLORMODE_IS_SET_BY_SA, "value");
404 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
405 std::shared_ptr<AbilityInfo> info = nullptr;
406 auto want = std::make_shared<Want>();
407 std::shared_ptr<AbilityLocalRecord> abilityRecord = std::make_shared<AbilityLocalRecord>(info, token, want, 0);
408 ohosApplication_->abilityRecordMgr_->abilityRecords_.emplace(token, abilityRecord);
409 sptr<AbilityThread> abilityThread = new (std::nothrow) AbilityRuntime::FAAbilityThread();
410 abilityRecord->SetAbilityThread(abilityThread);
411 ohosApplication_->OnConfigurationUpdated(config, level);
412 EXPECT_TRUE(!ohosApplication_->abilityRecordMgr_->abilityRecords_.empty());
413 EXPECT_TRUE(abilityRecord != nullptr);
414 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200 end.";
415 }
416
417 /*
418 * @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300
419 * @tc.name: OnConfigurationUpdated
420 * @tc.desc: Verify function OnConfigurationUpdated map abilityStages_ not empty
421 */
422 HWTEST_F(OHOSApplicationFirstTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300, TestSize.Level1)
423 {
424 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300 start.";
425 Configuration config;
426 ohosApplication_->abilityRuntimeContext_ = AbilityRuntime::ApplicationContext::GetInstance();
427 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, "zh_CN");
428 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE, "value");
429 config.AddItem(AAFwk::GlobalConfigurationKey::COLORMODE_IS_SET_BY_APP, "value");
430 config.AddItem(AAFwk::GlobalConfigurationKey::COLORMODE_IS_SET_BY_SA, "value");
431 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
432 ohosApplication_->configuration_ = std::make_shared<Configuration>();
433 ohosApplication_->configuration_->AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE, "value");
434 ohosApplication_->configuration_->AddItem(AAFwk::GlobalConfigurationKey::COLORMODE_IS_SET_BY_APP, "value");
435 ohosApplication_->configuration_->AddItem(AAFwk::GlobalConfigurationKey::COLORMODE_IS_SET_BY_SA, "value");
436 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
437 std::string moduleName = "entry";
438 std::shared_ptr<AbilityRuntime::AbilityStage> abilityStages = std::make_shared<AbilityRuntime::AbilityStage>();
439 ohosApplication_->abilityStages_.emplace(moduleName, abilityStages);
440 ohosApplication_->OnConfigurationUpdated(config);
441 EXPECT_TRUE(!ohosApplication_->abilityStages_.empty());
442 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300 end.";
443 }
444
445 /*
446 * @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0400
447 * @tc.name: OnConfigurationUpdated
448 * @tc.desc: Verify function OnConfigurationUpdated IsUpdateColorNeeded return true
449 */
450 HWTEST_F(OHOSApplicationFirstTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0400, TestSize.Level1)
451 {
452 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0400 start.";
453 Configuration config;
454 AbilityRuntime::SetLevel level = AbilityRuntime::SetLevel::Application;
455 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_FONT_SIZE_SCALE,
456 ConfigurationInner::SYSTEM_DEFAULT_FONTSIZE_SCALE);
457 ohosApplication_->abilityRuntimeContext_ = AbilityRuntime::ApplicationContext::GetInstance();
458 ohosApplication_->configuration_ = std::make_shared<Configuration>();
459 ohosApplication_->configuration_->AddItem(AAFwk::GlobalConfigurationKey::APP_FONT_SIZE_SCALE,
460 ConfigurationInner::IS_APP_FONT_FOLLOW_SYSTEM);
461 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
462 std::string colorMode = "auto";
463 ohosApplication_->configuration_->GetItem(AAFwk::GlobalConfigurationKey::APP_FONT_SIZE_SCALE);
464 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE, colorMode);
465 std::string colorMode1 = config.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE);
466 EXPECT_FALSE(colorMode1.empty());
467 AbilityRuntime::ApplicationConfigurationManager::GetInstance().SetLanguageSetLevel(level);
468 std::string testLanguge = "ch-zh";
469 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, testLanguge);
470 std::string language = config.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
471 EXPECT_FALSE(language.empty());
472 EXPECT_TRUE(ohosApplication_->IsUpdateColorNeeded(config, level));
473 EXPECT_TRUE(ohosApplication_->isUpdateFontSize(config, level));
474 EXPECT_TRUE(ohosApplication_->IsUpdateLanguageNeeded(config, level));
475 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0400 end.";
476 }
477
478 /*
479 * @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0500
480 * @tc.name: OnConfigurationUpdated
481 * @tc.desc: Verify function OnConfigurationUpdated IsUpdateColorNeeded return false
482 */
483 HWTEST_F(OHOSApplicationFirstTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0500, TestSize.Level1)
484 {
485 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0500 start.";
486 Configuration config;
487 AbilityRuntime::SetLevel level = AbilityRuntime::SetLevel::Application;
488 ohosApplication_->abilityRuntimeContext_ = AbilityRuntime::ApplicationContext::GetInstance();
489 ohosApplication_->configuration_ = std::make_shared<Configuration>();
490 ohosApplication_->configuration_->AddItem(AAFwk::GlobalConfigurationKey::APP_FONT_SIZE_SCALE,
491 ConfigurationInner::IS_APP_FONT_FOLLOW_SYSTEM);
492 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
493 std::string colorMode = "light";
494 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE, colorMode);
495 auto colorMode1 = config.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE);
496 AbilityRuntime::ApplicationConfigurationManager::GetInstance().SetColorModeSetLevel(level, colorMode1);
497 AbilityRuntime::SetLevel level1 = AbilityRuntime::SetLevel::System;
498 std::string colorModeIsSetBySa =
499 config.GetItem(AAFwk::GlobalConfigurationKey::COLORMODE_IS_SET_BY_SA);
500 AbilityRuntime::ApplicationConfigurationManager::GetInstance().SetLanguageSetLevel(level);
501 ohosApplication_->configuration_ = std::make_shared<Configuration>();
502 std::string language = config.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
503 EXPECT_TRUE(language.empty());
504 EXPECT_FALSE(ohosApplication_->IsUpdateColorNeeded(config, level1));
505 EXPECT_FALSE(ohosApplication_->isUpdateFontSize(config, level1));
506 EXPECT_FALSE(ohosApplication_->IsUpdateLanguageNeeded(config, level1));
507 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0500 end.";
508 }
509
510 /*
511 * @tc.number: OnConfigurationUpdated_0600
512 * @tc.name: OnConfigurationUpdated
513 * @tc.desc: Function test abilityRuntimeContext_ not empty
514 */
515 HWTEST_F(OHOSApplicationFirstTest, OnConfigurationUpdated_0600, TestSize.Level1)
516 {
517 TAG_LOGI(AAFwkTag::TEST, "OnConfigurationUpdated_0600 start");
518 std::string bundleName = "test.bundleName";
519 std::string moduleName = "test.moduleName";
520 std::string hapPath = "/data/app/testHap";
521 std::vector<std::string> overlayPaths;
522 std::unique_ptr<Global::Resource::ResConfig> resConfigBefore(Global::Resource::CreateResConfig());
523 ASSERT_NE(resConfigBefore, nullptr);
524 std::shared_ptr<Global::Resource::ResourceManager> resourceManager(Global::Resource::CreateResourceManager(
525 bundleName, moduleName, hapPath, overlayPaths, *resConfigBefore));
526 ASSERT_NE(resourceManager, nullptr);
527 auto contextImpl = std::make_shared<AbilityRuntime::ContextImpl>();
528 contextImpl->SetResourceManager(resourceManager);
529
530 auto appContext = std::make_shared<AbilityRuntime::ApplicationContext>();
531 appContext->AttachContextImpl(contextImpl);
532 ohosApplication_->SetApplicationContext(appContext);
533 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
534 ohosApplication_->configuration_ = std::make_shared<Configuration>();
535 ohosApplication_->configuration_->AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE, "value");
536 ohosApplication_->configuration_->AddItem(AAFwk::GlobalConfigurationKey::COLORMODE_IS_SET_BY_APP, "value");
537 ohosApplication_->configuration_->AddItem(AAFwk::GlobalConfigurationKey::COLORMODE_IS_SET_BY_SA, "value");
538 Configuration config;
539 ohosApplication_->abilityRuntimeContext_ = AbilityRuntime::ApplicationContext::GetInstance();
540 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, "zh_CN");
541 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE, "value");
542 config.AddItem(AAFwk::GlobalConfigurationKey::COLORMODE_IS_SET_BY_APP, "value");
543 config.AddItem(AAFwk::GlobalConfigurationKey::COLORMODE_IS_SET_BY_APP, "value");
544 config.AddItem(AAFwk::GlobalConfigurationKey::COLORMODE_IS_SET_BY_SA, "value");
545 config.AddItem(AAFwk::GlobalConfigurationKey::COLORMODE_IS_SET_BY_SA, "value");
546 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, "zh");
547 ohosApplication_->OnConfigurationUpdated(config);
548 EXPECT_TRUE(config.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE) == "zh");
549 TAG_LOGI(AAFwkTag::TEST, "OnConfigurationUpdated_0600 end");
550 }
551 } // namespace AppExecFwk
552 } // namespace OHOS
553