1 /*
2 * Copyright (c) 2022-2023 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 "application_context.h"
22 #include "application_impl.h"
23 #include "application_info.h"
24 #include "context_deal.h"
25 #include "context_impl.h"
26 #include "fa_ability_thread.h"
27 #include "hilog_tag_wrapper.h"
28 #include "mock_i_remote_object.h"
29 #include "mock_runtime.h"
30 #include "ohos_application.h"
31 #include "pac_map.h"
32 #include "resource_manager.h"
33 #include "runtime.h"
34 #include "ui_ability.h"
35 #undef private
36
37 using namespace testing;
38 using namespace testing::ext;
39
40 namespace OHOS {
41 namespace AppExecFwk {
42 class OHOSApplicationTest : public testing::Test {
43 public:
44 static void SetUpTestCase();
45 static void TearDownTestCase();
46 void SetUp() override;
47 void TearDown() override;
48 std::shared_ptr<OHOSApplication> ohosApplication_;
49 };
50
SetUpTestCase()51 void OHOSApplicationTest::SetUpTestCase()
52 {}
53
TearDownTestCase()54 void OHOSApplicationTest::TearDownTestCase()
55 {}
56
SetUp()57 void OHOSApplicationTest::SetUp()
58 {
59 ohosApplication_ = std::make_shared<OHOSApplication>();
60 }
61
TearDown()62 void OHOSApplicationTest::TearDown()
63 {
64 ohosApplication_ = nullptr;
65 }
66
67 /*
68 * @tc.number: AppExecFwk_OHOSApplicationTest_OnForeground_0100
69 * @tc.name: OnForeground
70 * @tc.desc: Verify function OnForeground pointer runtime_ empty
71 */
72 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnForeground_0100, TestSize.Level1)
73 {
74 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnForeground_0100 start.";
75 ohosApplication_->OnForeground();
76 EXPECT_TRUE(ohosApplication_->runtime_ == nullptr);
77 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnForeground_0100 end.";
78 }
79
80 /*
81 * @tc.number: AppExecFwk_OHOSApplicationTest_OnForeground_0200
82 * @tc.name: OnForeground
83 * @tc.desc: Verify function OnForeground pointer runtime_ not empty
84 */
85 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnForeground_0200, TestSize.Level1)
86 {
87 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnForeground_0200 start.";
88 ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
89 ohosApplication_->OnForeground();
90 EXPECT_TRUE(ohosApplication_->runtime_ != nullptr);
91 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnForeground_0200 end.";
92 }
93
94 /*
95 * @tc.number: AppExecFwk_OHOSApplicationTest_OnBackground_0100
96 * @tc.name: OnBackground
97 * @tc.desc: Verify function OnBackground pointer runtime_ empty
98 */
99 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnBackground_0100, TestSize.Level1)
100 {
101 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnBackground_0100 start.";
102 ohosApplication_->OnBackground();
103 EXPECT_TRUE(ohosApplication_->runtime_ == nullptr);
104 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnBackground_0100 end.";
105 }
106
107 /*
108 * @tc.number: AppExecFwk_OHOSApplicationTest_OnBackground_0200
109 * @tc.name: OnBackground
110 * @tc.desc: Verify function OnBackground pointer runtime_ not empty
111 */
112 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnBackground_0200, TestSize.Level1)
113 {
114 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnBackground_0200 start.";
115 ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
116 ohosApplication_->OnBackground();
117 EXPECT_TRUE(ohosApplication_->runtime_ != nullptr);
118 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnBackground_0200 end.";
119 }
120
121 /*
122 * @tc.number: AppExecFwk_OHOSApplicationTest_DumpApplication_0100
123 * @tc.name: DumpApplication
124 * @tc.desc: Verify function DumpApplication pointer record not empty
125 */
126 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_DumpApplication_0100, TestSize.Level1)
127 {
128 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DumpApplication_0100 start.";
129 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
130 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
131 std::shared_ptr<AbilityInfo> info = nullptr;
132 auto record = std::make_shared<AbilityLocalRecord>(info, token, nullptr, 0);
133 ohosApplication_->abilityRecordMgr_->abilityRecords_.emplace(token, record);
134 ohosApplication_->DumpApplication();
135 EXPECT_TRUE(record != nullptr);
136 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DumpApplication_0100 end.";
137 }
138
139 /*
140 * @tc.number: AppExecFwk_OHOSApplicationTest_DumpApplication_0200
141 * @tc.name: DumpApplication
142 * @tc.desc: Verify function DumpApplication pointer abilityInfo not empty
143 */
144 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_DumpApplication_0200, TestSize.Level1)
145 {
146 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DumpApplication_0200 start.";
147 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
148 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
149 std::shared_ptr<AbilityInfo> info = std::make_shared<AbilityInfo>();
150 auto record = std::make_shared<AbilityLocalRecord>(info, token, nullptr, 0);
151 info->permissions.push_back(std::string("abc"));
152 ohosApplication_->abilityRecordMgr_->abilityRecords_.emplace(token, record);
153 ohosApplication_->DumpApplication();
154 EXPECT_TRUE(record != nullptr);
155 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DumpApplication_0200 end.";
156 }
157
158 /*
159 * @tc.number: AppExecFwk_OHOSApplicationTest_DumpApplication_0300
160 * @tc.name: DumpApplication
161 * @tc.desc: Verify function DumpApplication pointer applicationInfoPtr not empty
162 */
163 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_DumpApplication_0300, TestSize.Level1)
164 {
165 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DumpApplication_0300 start.";
166 ohosApplication_->DumpApplication();
167 auto contextDeal = std::make_shared<ContextDeal>();
168 auto appInfo = std::make_shared<ApplicationInfo>();
169 contextDeal->SetApplicationInfo(appInfo);
170 ohosApplication_->AttachBaseContext(contextDeal);
171 ohosApplication_->DumpApplication();
172 EXPECT_TRUE(ohosApplication_->GetApplicationInfo() != nullptr);
173 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DumpApplication_0300 end.";
174 }
175
176 /*
177 * @tc.number: AppExecFwk_OHOSApplicationTest_SetRuntime_0100
178 * @tc.name: SetRuntime
179 * @tc.desc: Verify function SetRuntime pointer runtime empty
180 */
181 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetRuntime_0100, TestSize.Level1)
182 {
183 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetRuntime_0100 start.";
184 std::unique_ptr<AbilityRuntime::Runtime> runtime = nullptr;
185 ohosApplication_->SetRuntime(std::move(runtime));
186 EXPECT_TRUE(runtime == nullptr);
187 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetRuntime_0100 end.";
188 }
189
190 /*
191 * @tc.number: AppExecFwk_OHOSApplicationTest_SetRuntime_0200
192 * @tc.name: SetRuntime
193 * @tc.desc: Verify function SetRuntime pointer runtime_ not empty
194 */
195 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetRuntime_0200, TestSize.Level1)
196 {
197 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetRuntime_0200 start.";
198 std::unique_ptr<AbilityRuntime::Runtime> runtime = std::make_unique<AbilityRuntime::MockRuntime>();
199 EXPECT_TRUE(runtime != nullptr);
200 ohosApplication_->SetRuntime(std::move(runtime));
201 EXPECT_TRUE(ohosApplication_->runtime_ != nullptr);
202 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetRuntime_0200 end.";
203 }
204
205 /*
206 * @tc.number: AppExecFwk_OHOSApplicationTest_GetSpecifiedRuntime_0100
207 * @tc.name: GetSpecifiedRuntime
208 * @tc.desc: Verify function GetSpecifiedRuntime pointer runtime empty
209 */
210 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_GetSpecifiedRuntime_0100, TestSize.Level1)
211 {
212 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetSpecifiedRuntime_0100 start.";
213 std::unique_ptr<AbilityRuntime::Runtime> runtime = nullptr;
214 ohosApplication_->SetRuntime(std::move(runtime));
215 auto &runtimeSpec = ohosApplication_->GetSpecifiedRuntime(OHOS::AbilityRuntime::CODE_LANGUAGE_ARKTS_1_2);
216 EXPECT_TRUE(runtimeSpec == nullptr);
217 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetSpecifiedRuntime_0100 end.";
218 }
219
220 /*
221 * @tc.number: AppExecFwk_OHOSApplicationTest_GetSpecifiedRuntime_0200
222 * @tc.name: GetSpecifiedRuntime
223 * @tc.desc: Verify function GetSpecifiedRuntime pointer runtime not empty
224 */
225 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_GetSpecifiedRuntime_0200, TestSize.Level1)
226 {
227 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetSpecifiedRuntime_0200 start.";
228 std::unique_ptr<AbilityRuntime::Runtime> runtime = std::make_unique<AbilityRuntime::MockRuntime>();
229 EXPECT_TRUE(runtime != nullptr);
230 ohosApplication_->SetRuntime(std::move(runtime));
231 auto &runtimeSpec = ohosApplication_->GetSpecifiedRuntime(OHOS::AbilityRuntime::CODE_LANGUAGE_ARKTS_1_2);
232 EXPECT_TRUE(runtimeSpec != nullptr);
233 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetSpecifiedRuntime_0200 end.";
234 }
235
236 /*
237 * @tc.number: AppExecFwk_OHOSApplicationTest_SetApplicationContext_0100
238 * @tc.name: SetApplicationContext
239 * @tc.desc: Verify function SetApplicationContext pointer abilityRuntimeContext_ empty
240 */
241 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetApplicationContext_0100, TestSize.Level1)
242 {
243 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0100 start.";
244 std::shared_ptr<AbilityRuntime::ApplicationContext> abilityRuntimeContext = nullptr;
245 ohosApplication_->SetApplicationContext(abilityRuntimeContext);
246 EXPECT_TRUE(ohosApplication_->abilityRuntimeContext_ == nullptr);
247 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0100 end.";
248 }
249
250 /*
251 * @tc.number: AppExecFwk_OHOSApplicationTest_SetApplicationContext_0200
252 * @tc.name: SetApplicationContext
253 * @tc.desc: Verify function SetApplicationContext pointer abilityRuntimeContext_ not empty
254 */
255 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetApplicationContext_0200, TestSize.Level1)
256 {
257 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0200 start.";
258 std::shared_ptr<AbilityRuntime::ApplicationContext> abilityRuntimeContext =
259 std::make_shared<AbilityRuntime::ApplicationContext>();
260 EXPECT_TRUE(abilityRuntimeContext != nullptr);
261 ohosApplication_->SetApplicationContext(abilityRuntimeContext);
262 EXPECT_TRUE(ohosApplication_->abilityRuntimeContext_ != nullptr);
263 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0200 end.";
264 }
265
266 /*
267 * @tc.number: AppExecFwk_OHOSApplicationTest_SetApplicationContext_0300
268 * @tc.name: SetApplicationContext
269 * @tc.desc: Verify function SetApplicationContext RegisterAppGetSpecifiedRuntime
270 */
271 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetApplicationContext_0300, TestSize.Level1)
272 {
273 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0300 start.";
274 std::shared_ptr<AbilityRuntime::ApplicationContext> abilityRuntimeContext =
275 std::make_shared<AbilityRuntime::ApplicationContext>();
276 EXPECT_TRUE(abilityRuntimeContext != nullptr);
277 ohosApplication_->SetApplicationContext(abilityRuntimeContext);
278 EXPECT_TRUE(ohosApplication_->abilityRuntimeContext_ != nullptr);
279 ASSERT_NE(abilityRuntimeContext->appGetSpecifiedRuntimeCallback_, nullptr);
280
281 ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
282 const auto &runtime = abilityRuntimeContext->appGetSpecifiedRuntimeCallback_("");
283 EXPECT_EQ(ohosApplication_->runtime_.get(), runtime.get());
284 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0300 end.";
285 }
286
287 /*
288 * @tc.number: AppExecFwk_OHOSApplicationTest_SetApplicationContext_0400
289 * @tc.name: SetApplicationContext
290 * @tc.desc: Verify function SetApplicationContext RegisterAppGetSpecifiedRuntime null applicationSptr
291 */
292 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetApplicationContext_0400, TestSize.Level1)
293 {
294 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0400 start.";
295 std::shared_ptr<AbilityRuntime::ApplicationContext> abilityRuntimeContext =
296 std::make_shared<AbilityRuntime::ApplicationContext>();
297 EXPECT_TRUE(abilityRuntimeContext != nullptr);
298 ohosApplication_->SetApplicationContext(abilityRuntimeContext);
299 EXPECT_TRUE(ohosApplication_->abilityRuntimeContext_ != nullptr);
300 ASSERT_NE(abilityRuntimeContext->appGetSpecifiedRuntimeCallback_, nullptr);
301
302 ohosApplication_ = nullptr;
303 const auto &runtime = abilityRuntimeContext->appGetSpecifiedRuntimeCallback_("");
304 EXPECT_EQ(runtime, nullptr);
305 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0400 end.";
306 }
307
308 /*
309 * @tc.number: AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0100
310 * @tc.name: SetAbilityRecordMgr
311 * @tc.desc: Verify function SetAbilityRecordMgr pointer abilityRecordMgr_ empty
312 */
313 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0100, TestSize.Level1)
314 {
315 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0100 start.";
316 std::shared_ptr<AbilityRecordMgr> abilityRecordMgr = nullptr;
317 ohosApplication_->SetAbilityRecordMgr(abilityRecordMgr);
318 EXPECT_TRUE(ohosApplication_->abilityRecordMgr_ == nullptr);
319 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0100 end.";
320 }
321
322 /*
323 * @tc.number: AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0200
324 * @tc.name: SetAbilityRecordMgr
325 * @tc.desc: Verify function SetAbilityRecordMgr pointer abilityRecordMgr_ not empty
326 */
327 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0200, TestSize.Level1)
328 {
329 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0200 start.";
330 std::shared_ptr<AbilityRecordMgr> abilityRecordMgr = std::make_shared<AbilityRecordMgr>();
331 EXPECT_TRUE(abilityRecordMgr != nullptr);
332 ohosApplication_->SetAbilityRecordMgr(abilityRecordMgr);
333 EXPECT_TRUE(ohosApplication_->abilityRecordMgr_ != nullptr);
334 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0200 end.";
335 }
336
337 /*
338 * @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0100
339 * @tc.name: OnConfigurationUpdated
340 * @tc.desc: Verify function OnConfigurationUpdated pointer abilityRecordMgr_ empty
341 */
342 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0100, TestSize.Level1)
343 {
344 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0100 start.";
345 Configuration config;
346 ohosApplication_->OnConfigurationUpdated(config);
347 EXPECT_TRUE(ohosApplication_->abilityRecordMgr_ == nullptr);
348 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
349 ohosApplication_->OnConfigurationUpdated(config);
350 EXPECT_TRUE(ohosApplication_->configuration_ == nullptr);
351 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0100 end.";
352 }
353
354 /*
355 * @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200
356 * @tc.name: OnConfigurationUpdated
357 * @tc.desc: Verify function OnConfigurationUpdated pointer abilityRecord not empty
358 */
359 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200, TestSize.Level1)
360 {
361 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200 start.";
362 Configuration config;
363 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
364 ohosApplication_->configuration_ = std::make_shared<Configuration>();
365 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
366 std::shared_ptr<AbilityInfo> info = nullptr;
367 auto abilityRecord = std::make_shared<AbilityLocalRecord>(info, token, nullptr, 0);
368 ohosApplication_->abilityRecordMgr_->abilityRecords_.emplace(token, abilityRecord);
369 sptr<AbilityThread> abilityThread = new (std::nothrow) AbilityRuntime::FAAbilityThread();
370 abilityRecord->SetAbilityThread(abilityThread);
371 ohosApplication_->OnConfigurationUpdated(config);
372 EXPECT_TRUE(!ohosApplication_->abilityRecordMgr_->abilityRecords_.empty());
373 EXPECT_TRUE(abilityRecord != nullptr);
374 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200 end.";
375 }
376
377 /*
378 * @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300
379 * @tc.name: OnConfigurationUpdated
380 * @tc.desc: Verify function OnConfigurationUpdated map abilityStages_ not empty
381 */
382 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300, TestSize.Level1)
383 {
384 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300 start.";
385 Configuration config;
386 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
387 ohosApplication_->configuration_ = std::make_shared<Configuration>();
388 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
389 std::string moduleName = "entry";
390 std::shared_ptr<AbilityRuntime::AbilityStage> abilityStages = std::make_shared<AbilityRuntime::AbilityStage>();
391 ohosApplication_->abilityStages_.emplace(moduleName, abilityStages);
392 ohosApplication_->OnConfigurationUpdated(config);
393 EXPECT_TRUE(!ohosApplication_->abilityStages_.empty());
394 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300 end.";
395 }
396
397 /*
398 * @tc.number: OnConfigurationUpdated_0600
399 * @tc.name: OnConfigurationUpdated
400 * @tc.desc: Function test abilityRuntimeContext_ not empty
401 */
402 HWTEST_F(OHOSApplicationTest, OnConfigurationUpdated_0600, TestSize.Level1)
403 {
404 std::string bundleName = "test.bundleName";
405 std::string moduleName = "test.moduleName";
406 std::string hapPath = "/data/app/testHap";
407 std::vector<std::string> overlayPaths;
408 std::unique_ptr<Global::Resource::ResConfig> resConfigBefore(Global::Resource::CreateResConfig());
409 ASSERT_NE(resConfigBefore, nullptr);
410 std::shared_ptr<Global::Resource::ResourceManager> resourceManager(Global::Resource::CreateResourceManager(
411 bundleName, moduleName, hapPath, overlayPaths, *resConfigBefore));
412 ASSERT_NE(resourceManager, nullptr);
413 auto contextImpl = std::make_shared<AbilityRuntime::ContextImpl>();
414 contextImpl->SetResourceManager(resourceManager);
415
416 auto appContext = std::make_shared<AbilityRuntime::ApplicationContext>();
417 appContext->AttachContextImpl(contextImpl);
418 ohosApplication_->SetApplicationContext(appContext);
419 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
420 ohosApplication_->configuration_ = std::make_shared<Configuration>();
421
422 Configuration config;
423 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, "zh");
424 ohosApplication_->OnConfigurationUpdated(config);
425 std::unique_ptr<Global::Resource::ResConfig> resConfigAfter(Global::Resource::CreateResConfig());
426 ASSERT_NE(resConfigAfter, nullptr);
427 resourceManager->GetResConfig(*resConfigAfter);
428 const icu::Locale *localeInfo = resConfigAfter->GetLocaleInfo();
429 ASSERT_NE(localeInfo, nullptr);
430 TAG_LOGI(AAFwkTag::TEST, "Update config language %{public}s succeed.", localeInfo->getLanguage());
431 EXPECT_EQ(strcmp(localeInfo->getLanguage(), "zh"), 0);
432 }
433
434 /*
435 * @tc.number: AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0100
436 * @tc.name: OnMemoryLevel
437 * @tc.desc: Verify function OnMemoryLevel pointer abilityRecord not empty
438 */
439 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0100, TestSize.Level1)
440 {
441 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0100 start.";
442 constexpr int32_t level = 1;
443 ohosApplication_->OnMemoryLevel(level);
444 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
445 std::shared_ptr<AbilityInfo> info = nullptr;
446 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
447 auto abilityRecord = std::make_shared<AbilityLocalRecord>(info, token, nullptr, 0);
448 EXPECT_TRUE(abilityRecord != nullptr);
449 ohosApplication_->abilityRecordMgr_->abilityRecords_.emplace(token, abilityRecord);
450 sptr<AbilityThread> abilityThread = new (std::nothrow) AbilityRuntime::FAAbilityThread();
451 abilityRecord->SetAbilityThread(abilityThread);
452 ohosApplication_->OnMemoryLevel(level);
453 EXPECT_FALSE(ohosApplication_->abilityRecordMgr_->abilityRecords_.empty());
454 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0100 end.";
455 }
456
457 /*
458 * @tc.number: AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0200
459 * @tc.name: OnMemoryLevel
460 * @tc.desc: Verify function OnMemoryLevel map abilityStages_ not empty
461 */
462 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0200, TestSize.Level1)
463 {
464 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0200 start.";
465 constexpr int32_t level = 1;
466 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
467 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
468 std::string moduleName1 = "entry1";
469 std::string moduleName2 = "entry2";
470 std::shared_ptr<AbilityRuntime::AbilityStage> abilityStages1 = std::make_shared<AbilityRuntime::AbilityStage>();
471 std::shared_ptr<AbilityRuntime::AbilityStage> abilityStages2 = nullptr;
472 ohosApplication_->abilityStages_.emplace(moduleName1, abilityStages1);
473 ohosApplication_->abilityStages_.emplace(moduleName2, abilityStages2);
474 ohosApplication_->OnMemoryLevel(level);
475 EXPECT_TRUE(!ohosApplication_->abilityStages_.empty());
476 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0200 end.";
477 }
478
479 /*
480 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0100
481 * @tc.name: AddAbilityStage
482 * @tc.desc: Verify function AddAbilityStage pointer abilityRecord empty
483 */
484 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0100, TestSize.Level1)
485 {
486 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0100 start.";
487 ohosApplication_->OnStart();
488 std::shared_ptr<AbilityLocalRecord> abilityRecord = nullptr;
__anon8b2eb2fa0102(const std::shared_ptr<AbilityRuntime::Context> &) 489 auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
490 bool isAsyncCallback = false;
491 ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
492 EXPECT_TRUE(abilityRecord == nullptr);
493 ohosApplication_->OnTerminate();
494 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0100 end.";
495 }
496
497 /*
498 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0200
499 * @tc.name: AddAbilityStage
500 * @tc.desc: Verify function AddAbilityStage pointer abilityInfo empty
501 */
502 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0200, TestSize.Level1)
503 {
504 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0200 start.";
505 std::shared_ptr<AbilityLocalRecord> abilityRecord = nullptr;
506 std::shared_ptr<AbilityInfo> abilityInfo = nullptr;
__anon8b2eb2fa0202(const std::shared_ptr<AbilityRuntime::Context> &) 507 auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
508 bool isAsyncCallback = false;
509 ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
510 EXPECT_TRUE(abilityInfo == nullptr);
511 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0200 end.";
512 }
513
514 /*
515 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0300
516 * @tc.name: AddAbilityStage
517 * @tc.desc: Verify function AddAbilityStage pointer hapModuleInfo empty
518 */
519 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0300, TestSize.Level1)
520 {
521 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0300 start.";
522 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
523 std::shared_ptr<AbilityInfo> info = std::make_shared<AbilityInfo>();
524 auto want = std::make_shared<Want>();
525 std::shared_ptr<AbilityLocalRecord> abilityRecord = std::make_shared<AbilityLocalRecord>(info, token, want, 0);
526 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
__anon8b2eb2fa0302(const std::shared_ptr<AbilityRuntime::Context> &) 527 auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
528 bool isAsyncCallback = false;
529 ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
530 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0300 end.";
531 }
532
533 /*
534 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0400
535 * @tc.name: AddAbilityStage
536 * @tc.desc: Verify function AddAbilityStage abilityRecord->GetWant() not empty
537 */
538 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0400, TestSize.Level1)
539 {
540 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0400 start.";
541 std::shared_ptr<AbilityInfo> info = std::make_shared<AbilityInfo>();
542 info->applicationInfo.multiProjects = true;
543 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
544 auto abilityRecord = std::make_shared<AbilityLocalRecord>(info, token, nullptr, 0);
__anon8b2eb2fa0402(const std::shared_ptr<AbilityRuntime::Context> &) 545 auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
546 bool isAsyncCallback = false;
547 ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
548 EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
549 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0400 end.";
550 }
551
552 /*
553 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0500
554 * @tc.name: AddAbilityStage
555 * @tc.desc: Verify function AddAbilityStage pointer abilityStages not empty
556 */
557 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0500, TestSize.Level1)
558 {
559 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0500 start.";
560 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
561 std::shared_ptr<AbilityInfo> info = nullptr;
562 std::string moduleName = "entry";
563 auto abilityRecord = std::make_shared<AbilityLocalRecord>(info, token, nullptr, 0);
564 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
565 std::shared_ptr<AbilityRuntime::AbilityStage> abilityStages = std::make_shared<AbilityRuntime::AbilityStage>();
566 ohosApplication_->abilityStages_.emplace(moduleName, abilityStages);
__anon8b2eb2fa0502(const std::shared_ptr<AbilityRuntime::Context> &) 567 auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
568 bool isAsyncCallback = false;
569 ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
570 EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
571 EXPECT_TRUE(abilityStages != nullptr);
572 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0500 end.";
573 }
574
575 /*
576 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0600
577 * @tc.name: AddAbilityStage
578 * @tc.desc: Verify function AddAbilityStage pointer token empty
579 */
580 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0600, TestSize.Level1)
581 {
582 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0600 start.";
583 sptr<Notification::MockIRemoteObject> token;
584 std::shared_ptr<AbilityInfo> info = std::make_shared<AbilityInfo>();
585 info->moduleName = "entry";
586 auto abilityRecord = std::make_shared<AbilityLocalRecord>(info, token, nullptr, 0);
__anon8b2eb2fa0602(const std::shared_ptr<AbilityRuntime::Context> &) 587 auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
588 bool isAsyncCallback = false;
589 ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
590 ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
591 EXPECT_TRUE(token == nullptr);
592 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0600 end.";
593 }
594
595 /*
596 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0700
597 * @tc.name: AddAbilityStage
598 * @tc.desc: Verify function AddAbilityStage pointer token not empty
599 */
600 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0700, TestSize.Level1)
601 {
602 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0700 start.";
603 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
604 std::shared_ptr<AbilityInfo> info = std::make_shared<AbilityInfo>();
605 auto abilityRecord = std::make_shared<AbilityLocalRecord>(info, token, nullptr, 0);
606 abilityRecord->token_ = new (std::nothrow) Notification::MockIRemoteObject();
__anon8b2eb2fa0702(const std::shared_ptr<AbilityRuntime::Context> &) 607 auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
608 bool isAsyncCallback = false;
609 ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
610 EXPECT_TRUE(token != nullptr);
611 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0700 end.";
612 }
613
614 /*
615 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0800
616 * @tc.name: AddAbilityStage
617 * @tc.desc: Verify function AddAbilityStage pointer abilityRuntimeContext_ empty
618 */
619 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0800, TestSize.Level1)
620 {
621 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0800 start.";
622 HapModuleInfo hapModuleInfo;
__anon8b2eb2fa0802() 623 auto callback = []() {};
624 bool isAsyncCallback = false;
625 ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
626 EXPECT_TRUE(ohosApplication_->abilityRuntimeContext_ == nullptr);
627 EXPECT_FALSE(ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback));
628 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0800 end.";
629 }
630
631 /*
632 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0900
633 * @tc.name: AddAbilityStage
634 * @tc.desc: Verify function AddAbilityStage pointer runtime_ empty
635 */
636 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0900, TestSize.Level1)
637 {
638 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0900 start.";
639 HapModuleInfo hapModuleInfo;
__anon8b2eb2fa0902() 640 auto callback = []() {};
641 bool isAsyncCallback = false;
642 ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
643 ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
644 EXPECT_TRUE(ohosApplication_->runtime_ == nullptr);
645 EXPECT_FALSE(ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback));
646 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0900 end.";
647 }
648
649 /*
650 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_01000
651 * @tc.name: AddAbilityStage
652 * @tc.desc: Verify function AddAbilityStage map abilityStages_ not empty
653 */
654 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_01000, TestSize.Level1)
655 {
656 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01000 start.";
657 HapModuleInfo hapModuleInfo;
__anon8b2eb2fa0a02() 658 auto callback = []() {};
659 bool isAsyncCallback = false;
660 std::string moduleName = "entry";
661 ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
662 std::shared_ptr<AbilityRuntime::AbilityStage> abilityStages = std::make_shared<AbilityRuntime::AbilityStage>();
663 ohosApplication_->abilityStages_.emplace(moduleName, abilityStages);
664 ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
665 ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
666 EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
667 EXPECT_FALSE(ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback));
668 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01000 end.";
669 }
670
671 /*
672 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_01100
673 * @tc.name: AddAbilityStage
674 * @tc.desc: Verify function AddAbilityStage variable moduleInfo empty
675 */
676 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_01100, TestSize.Level1)
677 {
678 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01100 start.";
679 HapModuleInfo hapModuleInfo;
__anon8b2eb2fa0b02() 680 auto callback = []() {};
681 bool isAsyncCallback = false;
682 ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
683 ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
684 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
685 ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
686 ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
687 auto contextImpl = std::make_shared<AbilityRuntime::ContextImpl>();
688 auto appInfo = std::make_shared<ApplicationInfo>();
689 appInfo->multiProjects = true;
690 contextImpl->SetApplicationInfo(appInfo);
691 ohosApplication_->abilityRuntimeContext_->AttachContextImpl(contextImpl);
692 ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
693 EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
694 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01100 end.";
695 }
696
697 /*
698 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_01200
699 * @tc.name: AddAbilityStage
700 * @tc.desc: Verify function AddAbilityStage abilityRuntimeContext_->GetApplicationInfo() true
701 */
702 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_01200, TestSize.Level1)
703 {
704 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01200 start.";
705 HapModuleInfo hapModuleInfo;
__anon8b2eb2fa0c02() 706 auto callback = []() {};
707 bool isAsyncCallback = false;
708 ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
709 ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
710 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
711 ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
712 ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
713 auto contextImpl = std::make_shared<AbilityRuntime::ContextImpl>();
714 auto appInfo = std::make_shared<ApplicationInfo>();
715 appInfo->multiProjects = false;
716 contextImpl->SetApplicationInfo(appInfo);
717 ohosApplication_->abilityRuntimeContext_->AttachContextImpl(contextImpl);
718 ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
719 EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
720 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01200 end.";
721 }
722
723 /*
724 * @tc.number: AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0100
725 * @tc.name: CleanAbilityStage
726 * @tc.desc: Verify function CleanAbilityStage pointer abilityInfo empty
727 */
728 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0100, TestSize.Level1)
729 {
730 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0100 start.";
731 std::shared_ptr<AbilityInfo> abilityInfo = nullptr;
732 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
733 ohosApplication_->CleanAbilityStage(token, abilityInfo, false);
734 EXPECT_TRUE(abilityInfo == nullptr);
735 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0100 end.";
736 }
737
738 /*
739 * @tc.number: AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0200
740 * @tc.name: CleanAbilityStage
741 * @tc.desc: Verify function CleanAbilityStage pointer token empty
742 */
743 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0200, TestSize.Level1)
744 {
745 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0200 start.";
746 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
747 sptr<Notification::MockIRemoteObject> token = nullptr;
748 ohosApplication_->CleanAbilityStage(token, abilityInfo, false);
749 EXPECT_TRUE(token == nullptr);
750 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0200 end.";
751 }
752
753 /*
754 * @tc.number: AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0300
755 * @tc.name: CleanAbilityStage
756 * @tc.desc: Verify function CleanAbilityStage map abilityRecords_ not empty
757 */
758 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0300, TestSize.Level1)
759 {
760 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0300 start.";
761 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
762 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
763 abilityInfo->moduleName = "entry";
764 std::shared_ptr<AbilityRuntime::AbilityStage> abilityStage = std::make_shared<AbilityRuntime::AbilityStage>();
765 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
766 ohosApplication_->abilityStages_.emplace(abilityInfo->moduleName, abilityStage);
767 EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
768 ohosApplication_->CleanAbilityStage(token, abilityInfo, false);
769 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
770 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0300 end.";
771 }
772
773 /*
774 * @tc.number: AppExecFwk_OHOSApplicationTest_GetAppContext_0100
775 * @tc.name: GetAppContext
776 * @tc.desc: Verify function GetAppContext pointer token empty
777 */
778 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_GetAppContext_0100, TestSize.Level1)
779 {
780 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetAppContext_0100 start.";
781 auto context = ohosApplication_->GetAppContext();
782 EXPECT_TRUE(context == nullptr);
783 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetAppContext_0100 end.";
784 }
785
786 /*
787 * @tc.number: AppExecFwk_OHOSApplicationTest_GetRuntime_0100
788 * @tc.name: GetRuntime
789 * @tc.desc: Verify function GetRuntime pointer token empty
790 */
791 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_GetRuntime_0100, TestSize.Level1)
792 {
793 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetRuntime_0100 start.";
794 auto &runtime = ohosApplication_->GetRuntime();
795 EXPECT_TRUE(runtime == nullptr);
796 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetRuntime_0100 end.";
797 }
798
799 /*
800 * @tc.number: AppExecFwk_OHOSApplicationTest_SetConfiguration_0100
801 * @tc.name: SetConfiguration
802 * @tc.desc: Verify function SetConfiguration pointer token empty
803 */
804 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetConfiguration_0100, TestSize.Level1)
805 {
806 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetConfiguration_0100 start.";
807 Configuration config;
808 ohosApplication_->configuration_ = nullptr;
809 ohosApplication_->SetConfiguration(config);
810 ohosApplication_->SetConfiguration(config);
811 EXPECT_TRUE(ohosApplication_->configuration_ != nullptr);
812 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetConfiguration_0100 end.";
813 }
814
815 /*
816 * @tc.number: AppExecFwk_OHOSApplicationTest_ScheduleAcceptWant_0100
817 * @tc.name: ScheduleAcceptWant
818 * @tc.desc: Verify function ScheduleAcceptWant pointer abilityStage not empty
819 */
820 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_ScheduleAcceptWant_0100, TestSize.Level1)
821 {
822 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_ScheduleAcceptWant_0100 start.";
823 Want want;
824 bool isAsync = false;
825 std::string moduleName = "entry";
826 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
827 std::shared_ptr<AbilityRuntime::AbilityStage> abilityStage = std::make_shared<AbilityRuntime::AbilityStage>();
828 ohosApplication_->abilityStages_.emplace(moduleName, abilityStage);
829 EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
__anon8b2eb2fa0d02(std::string) 830 auto callback = [](std::string) {};
831 ohosApplication_->ScheduleAcceptWant(want, moduleName, callback, isAsync);
832 EXPECT_TRUE(abilityStage != nullptr);
833 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_ScheduleAcceptWant_0100 end.";
834 }
835
836 /*
837 * @tc.number: AppExecFwk_OHOSApplicationTest_GetConfiguration_0100
838 * @tc.name: GetConfiguration
839 * @tc.desc: Verify function GetConfiguration pointer configuration_ not empty
840 */
841 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_GetConfiguration_0100, TestSize.Level1)
842 {
843 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetConfiguration_0100 start.";
844 Configuration config;
845 ohosApplication_->configuration_ = nullptr;
846 ohosApplication_->GetConfiguration();
847 EXPECT_TRUE(ohosApplication_->configuration_ == nullptr);
848 ohosApplication_->SetConfiguration(config);
849 ohosApplication_->GetConfiguration();
850 EXPECT_TRUE(ohosApplication_->configuration_ != nullptr);
851 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetConfiguration_0100 end.";
852 }
853
854 /*
855 * @tc.number: AppExecFwk_OHOSApplicationTest_SetExtensionTypeMap_0100
856 * @tc.name: SetExtensionTypeMap
857 * @tc.desc: Verify function SetExtensionTypeMap map extensionTypeMap_ not empty
858 */
859 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetExtensionTypeMap_0100, TestSize.Level1)
860 {
861 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetExtensionTypeMap_0100 start.";
862 const std::string name = "entry";
863 constexpr int32_t id = 1;
864 std::map<int32_t, std::string> map;
865 map.emplace(id, name);
866 ohosApplication_->SetExtensionTypeMap(map);
867 EXPECT_FALSE(ohosApplication_->extensionTypeMap_.empty());
868 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetExtensionTypeMap_0100 end.";
869 }
870
871 /*
872 * @tc.number: AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0100
873 * @tc.name: NotifyLoadRepairPatch
874 * @tc.desc: Verify function NotifyLoadRepairPatch pointer runtime_ empty
875 */
876 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0100, TestSize.Level1)
877 {
878 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0100 start.";
879 const std::string hqfFile = "hqfFile";
880 const std::string hapPat = "hapPat";
881 EXPECT_TRUE(ohosApplication_->NotifyLoadRepairPatch(hqfFile, hapPat));
882 EXPECT_TRUE(ohosApplication_->runtime_ == nullptr);
883 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0100 end.";
884 }
885
886 /*
887 * @tc.number: AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0200
888 * @tc.name: NotifyLoadRepairPatch
889 * @tc.desc: Verify function NotifyLoadRepairPatch function LoadRepairPatch called
890 */
891 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0200, TestSize.Level1)
892 {
893 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0200 start.";
894 const std::string hqfFile = "hqfFile";
895 const std::string hapPath = "hapPath";
896 ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
897 ohosApplication_->NotifyLoadRepairPatch(hqfFile, hapPath);
898 EXPECT_TRUE(ohosApplication_->runtime_ != nullptr);
899 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0200 end.";
900 }
901
902 /*
903 * @tc.number: AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0100
904 * @tc.name: NotifyHotReloadPage
905 * @tc.desc: Verify function NotifyHotReloadPage pointer runtime_ empty
906 */
907 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0100, TestSize.Level1)
908 {
909 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0100 start.";
910 ohosApplication_->NotifyHotReloadPage();
911 EXPECT_TRUE(ohosApplication_->runtime_ == nullptr);
912 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0100 end.";
913 }
914
915 /*
916 * @tc.number: AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0200
917 * @tc.name: NotifyHotReloadPage
918 * @tc.desc: Verify function NotifyHotReloadPage pointer runtime_ not empty
919 */
920 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0200, TestSize.Level1)
921 {
922 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0200 start.";
923 ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
924 ohosApplication_->NotifyHotReloadPage();
925 EXPECT_TRUE(ohosApplication_->runtime_ != nullptr);
926 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0200 end.";
927 }
928
929 /*
930 * @tc.number: AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0100
931 * @tc.name: NotifyUnLoadRepairPatch
932 * @tc.desc: Verify function NotifyHotReloadPage pointer runtime_ empty
933 */
934 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0100, TestSize.Level1)
935 {
936 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0100 start.";
937 std::string hqfFile = "hqfFile";
938 ohosApplication_->NotifyUnLoadRepairPatch(hqfFile);
939 EXPECT_TRUE(ohosApplication_->runtime_ == nullptr);
940 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0100 end.";
941 }
942
943 /*
944 * @tc.number: AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0200
945 * @tc.name: NotifyUnLoadRepairPatch
946 * @tc.desc: Verify function NotifyHotReloadPage pointer runtime_ not empty
947 */
948 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0200, TestSize.Level1)
949 {
950 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0200 start.";
951 ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
952 std::string hqfFile = "entry";
953 ohosApplication_->NotifyUnLoadRepairPatch(hqfFile);
954 EXPECT_TRUE(ohosApplication_->runtime_ != nullptr);
955 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0200 end.";
956 }
957
958 /*
959 * @tc.number: AppExecFwk_OHOSApplicationTest_SetAppEnv_0100
960 * @tc.name: SetAppEnv
961 * @tc.desc: Verify SetAppEnv function
962 */
963 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetAppEnv_0100, TestSize.Level1)
964 {
965 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAppEnv_0100 start.";
966 AppEnvironment appEnvironment;
967 appEnvironment.name = "env_key_demo";
968 appEnvironment.value = "env_value_demo";
969 std::vector<AppEnvironment> appEnvironments = {appEnvironment};
970 ohosApplication_->SetAppEnv(appEnvironments);
971 std::string appEnvVal = getenv(appEnvironment.name.c_str());
972 EXPECT_EQ(appEnvVal, appEnvironment.value);
973 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAppEnv_0100 end.";
974 }
975
976 /*
977 * @tc.number: AppExecFwk_OHOSApplicationTest_ScheduleNewProcessRequest_0100
978 * @tc.name: ScheduleNewProcessRequest
979 * @tc.desc: Verify function ScheduleNewProcessRequest pointer abilityStage not empty
980 */
981 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_ScheduleNewProcessRequest_0100, TestSize.Level1)
982 {
983 Want want;
984 bool isAsync = false;
985 std::string moduleName = "entry";
986 ohosApplication_->ScheduleNewProcessRequest(want, moduleName, nullptr, isAsync);
987 EXPECT_FALSE(isAsync);
__anon8b2eb2fa0e02(std::string) 988 auto callback = [](std::string) {};
989 ohosApplication_->ScheduleNewProcessRequest(want, moduleName, callback, isAsync);
990 EXPECT_FALSE(isAsync);
991 std::shared_ptr<AbilityRuntime::AbilityStage> abilityStage = std::make_shared<AbilityRuntime::AbilityStage>();
992 ohosApplication_->abilityStages_.emplace(moduleName, abilityStage);
993 std::string testName = "testName";
994 ohosApplication_->ScheduleNewProcessRequest(want, testName, callback, isAsync);
995 EXPECT_FALSE(isAsync);
996 ohosApplication_->ScheduleNewProcessRequest(want, moduleName, callback, isAsync);
997 EXPECT_FALSE(isAsync);
998 }
999 } // namespace AppExecFwk
1000 } // namespace OHOS
1001