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_SetApplicationContext_0100
207 * @tc.name: SetApplicationContext
208 * @tc.desc: Verify function SetApplicationContext pointer abilityRuntimeContext_ empty
209 */
210 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetApplicationContext_0100, TestSize.Level1)
211 {
212 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0100 start.";
213 std::shared_ptr<AbilityRuntime::ApplicationContext> abilityRuntimeContext = nullptr;
214 ohosApplication_->SetApplicationContext(abilityRuntimeContext);
215 EXPECT_TRUE(ohosApplication_->abilityRuntimeContext_ == nullptr);
216 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0100 end.";
217 }
218
219 /*
220 * @tc.number: AppExecFwk_OHOSApplicationTest_SetApplicationContext_0200
221 * @tc.name: SetApplicationContext
222 * @tc.desc: Verify function SetApplicationContext pointer abilityRuntimeContext_ not empty
223 */
224 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetApplicationContext_0200, TestSize.Level1)
225 {
226 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0200 start.";
227 std::shared_ptr<AbilityRuntime::ApplicationContext> abilityRuntimeContext =
228 std::make_shared<AbilityRuntime::ApplicationContext>();
229 EXPECT_TRUE(abilityRuntimeContext != nullptr);
230 ohosApplication_->SetApplicationContext(abilityRuntimeContext);
231 EXPECT_TRUE(ohosApplication_->abilityRuntimeContext_ != nullptr);
232 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0200 end.";
233 }
234
235 /*
236 * @tc.number: AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0100
237 * @tc.name: SetAbilityRecordMgr
238 * @tc.desc: Verify function SetAbilityRecordMgr pointer abilityRecordMgr_ empty
239 */
240 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0100, TestSize.Level1)
241 {
242 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0100 start.";
243 std::shared_ptr<AbilityRecordMgr> abilityRecordMgr = nullptr;
244 ohosApplication_->SetAbilityRecordMgr(abilityRecordMgr);
245 EXPECT_TRUE(ohosApplication_->abilityRecordMgr_ == nullptr);
246 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0100 end.";
247 }
248
249 /*
250 * @tc.number: AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0200
251 * @tc.name: SetAbilityRecordMgr
252 * @tc.desc: Verify function SetAbilityRecordMgr pointer abilityRecordMgr_ not empty
253 */
254 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0200, TestSize.Level1)
255 {
256 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0200 start.";
257 std::shared_ptr<AbilityRecordMgr> abilityRecordMgr = std::make_shared<AbilityRecordMgr>();
258 EXPECT_TRUE(abilityRecordMgr != nullptr);
259 ohosApplication_->SetAbilityRecordMgr(abilityRecordMgr);
260 EXPECT_TRUE(ohosApplication_->abilityRecordMgr_ != nullptr);
261 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0200 end.";
262 }
263
264 /*
265 * @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0100
266 * @tc.name: OnConfigurationUpdated
267 * @tc.desc: Verify function OnConfigurationUpdated pointer abilityRecordMgr_ empty
268 */
269 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0100, TestSize.Level1)
270 {
271 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0100 start.";
272 Configuration config;
273 ohosApplication_->OnConfigurationUpdated(config);
274 EXPECT_TRUE(ohosApplication_->abilityRecordMgr_ == nullptr);
275 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
276 ohosApplication_->OnConfigurationUpdated(config);
277 EXPECT_TRUE(ohosApplication_->configuration_ == nullptr);
278 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0100 end.";
279 }
280
281 /*
282 * @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200
283 * @tc.name: OnConfigurationUpdated
284 * @tc.desc: Verify function OnConfigurationUpdated pointer abilityRecord not empty
285 */
286 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200, TestSize.Level1)
287 {
288 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200 start.";
289 Configuration config;
290 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
291 ohosApplication_->configuration_ = std::make_shared<Configuration>();
292 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
293 std::shared_ptr<AbilityInfo> info = nullptr;
294 auto abilityRecord = std::make_shared<AbilityLocalRecord>(info, token, nullptr, 0);
295 ohosApplication_->abilityRecordMgr_->abilityRecords_.emplace(token, abilityRecord);
296 sptr<AbilityThread> abilityThread = new (std::nothrow) AbilityRuntime::FAAbilityThread();
297 abilityRecord->SetAbilityThread(abilityThread);
298 ohosApplication_->OnConfigurationUpdated(config);
299 EXPECT_TRUE(!ohosApplication_->abilityRecordMgr_->abilityRecords_.empty());
300 EXPECT_TRUE(abilityRecord != nullptr);
301 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200 end.";
302 }
303
304 /*
305 * @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300
306 * @tc.name: OnConfigurationUpdated
307 * @tc.desc: Verify function OnConfigurationUpdated map abilityStages_ not empty
308 */
309 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300, TestSize.Level1)
310 {
311 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300 start.";
312 Configuration config;
313 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
314 ohosApplication_->configuration_ = std::make_shared<Configuration>();
315 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
316 std::string moduleName = "entry";
317 std::shared_ptr<AbilityRuntime::AbilityStage> abilityStages = std::make_shared<AbilityRuntime::AbilityStage>();
318 ohosApplication_->abilityStages_.emplace(moduleName, abilityStages);
319 ohosApplication_->OnConfigurationUpdated(config);
320 EXPECT_TRUE(!ohosApplication_->abilityStages_.empty());
321 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300 end.";
322 }
323
324 /*
325 * @tc.number: OnConfigurationUpdated_0600
326 * @tc.name: OnConfigurationUpdated
327 * @tc.desc: Function test abilityRuntimeContext_ not empty
328 */
329 HWTEST_F(OHOSApplicationTest, OnConfigurationUpdated_0600, TestSize.Level1)
330 {
331 std::string bundleName = "test.bundleName";
332 std::string moduleName = "test.moduleName";
333 std::string hapPath = "/data/app/testHap";
334 std::vector<std::string> overlayPaths;
335 std::unique_ptr<Global::Resource::ResConfig> resConfigBefore(Global::Resource::CreateResConfig());
336 ASSERT_NE(resConfigBefore, nullptr);
337 std::shared_ptr<Global::Resource::ResourceManager> resourceManager(Global::Resource::CreateResourceManager(
338 bundleName, moduleName, hapPath, overlayPaths, *resConfigBefore));
339 ASSERT_NE(resourceManager, nullptr);
340 auto contextImpl = std::make_shared<AbilityRuntime::ContextImpl>();
341 contextImpl->SetResourceManager(resourceManager);
342
343 auto appContext = std::make_shared<AbilityRuntime::ApplicationContext>();
344 appContext->AttachContextImpl(contextImpl);
345 ohosApplication_->SetApplicationContext(appContext);
346 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
347 ohosApplication_->configuration_ = std::make_shared<Configuration>();
348
349 Configuration config;
350 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, "zh");
351 ohosApplication_->OnConfigurationUpdated(config);
352 std::unique_ptr<Global::Resource::ResConfig> resConfigAfter(Global::Resource::CreateResConfig());
353 ASSERT_NE(resConfigAfter, nullptr);
354 resourceManager->GetResConfig(*resConfigAfter);
355 const icu::Locale *localeInfo = resConfigAfter->GetLocaleInfo();
356 ASSERT_NE(localeInfo, nullptr);
357 TAG_LOGI(AAFwkTag::TEST, "Update config language %{public}s succeed.", localeInfo->getLanguage());
358 EXPECT_EQ(strcmp(localeInfo->getLanguage(), "zh"), 0);
359 }
360
361 /*
362 * @tc.number: AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0100
363 * @tc.name: OnMemoryLevel
364 * @tc.desc: Verify function OnMemoryLevel pointer abilityRecord not empty
365 */
366 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0100, TestSize.Level1)
367 {
368 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0100 start.";
369 constexpr int32_t level = 1;
370 ohosApplication_->OnMemoryLevel(level);
371 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
372 std::shared_ptr<AbilityInfo> info = nullptr;
373 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
374 auto abilityRecord = std::make_shared<AbilityLocalRecord>(info, token, nullptr, 0);
375 EXPECT_TRUE(abilityRecord != nullptr);
376 ohosApplication_->abilityRecordMgr_->abilityRecords_.emplace(token, abilityRecord);
377 sptr<AbilityThread> abilityThread = new (std::nothrow) AbilityRuntime::FAAbilityThread();
378 abilityRecord->SetAbilityThread(abilityThread);
379 ohosApplication_->OnMemoryLevel(level);
380 EXPECT_FALSE(ohosApplication_->abilityRecordMgr_->abilityRecords_.empty());
381 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0100 end.";
382 }
383
384 /*
385 * @tc.number: AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0200
386 * @tc.name: OnMemoryLevel
387 * @tc.desc: Verify function OnMemoryLevel map abilityStages_ not empty
388 */
389 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0200, TestSize.Level1)
390 {
391 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0200 start.";
392 constexpr int32_t level = 1;
393 ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
394 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
395 std::string moduleName1 = "entry1";
396 std::string moduleName2 = "entry2";
397 std::shared_ptr<AbilityRuntime::AbilityStage> abilityStages1 = std::make_shared<AbilityRuntime::AbilityStage>();
398 std::shared_ptr<AbilityRuntime::AbilityStage> abilityStages2 = nullptr;
399 ohosApplication_->abilityStages_.emplace(moduleName1, abilityStages1);
400 ohosApplication_->abilityStages_.emplace(moduleName2, abilityStages2);
401 ohosApplication_->OnMemoryLevel(level);
402 EXPECT_TRUE(!ohosApplication_->abilityStages_.empty());
403 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0200 end.";
404 }
405
406 /*
407 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0100
408 * @tc.name: AddAbilityStage
409 * @tc.desc: Verify function AddAbilityStage pointer abilityRecord empty
410 */
411 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0100, TestSize.Level1)
412 {
413 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0100 start.";
414 ohosApplication_->OnStart();
415 std::shared_ptr<AbilityLocalRecord> abilityRecord = nullptr;
__anon99ebcc580102(const std::shared_ptr<AbilityRuntime::Context> &) 416 auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
417 bool isAsyncCallback = false;
418 ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
419 EXPECT_TRUE(abilityRecord == nullptr);
420 ohosApplication_->OnTerminate();
421 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0100 end.";
422 }
423
424 /*
425 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0200
426 * @tc.name: AddAbilityStage
427 * @tc.desc: Verify function AddAbilityStage pointer abilityInfo empty
428 */
429 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0200, TestSize.Level1)
430 {
431 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0200 start.";
432 std::shared_ptr<AbilityLocalRecord> abilityRecord = nullptr;
433 std::shared_ptr<AbilityInfo> abilityInfo = nullptr;
__anon99ebcc580202(const std::shared_ptr<AbilityRuntime::Context> &) 434 auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
435 bool isAsyncCallback = false;
436 ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
437 EXPECT_TRUE(abilityInfo == nullptr);
438 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0200 end.";
439 }
440
441 /*
442 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0300
443 * @tc.name: AddAbilityStage
444 * @tc.desc: Verify function AddAbilityStage pointer hapModuleInfo empty
445 */
446 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0300, TestSize.Level1)
447 {
448 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0300 start.";
449 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
450 std::shared_ptr<AbilityInfo> info = std::make_shared<AbilityInfo>();
451 auto want = std::make_shared<Want>();
452 std::shared_ptr<AbilityLocalRecord> abilityRecord = std::make_shared<AbilityLocalRecord>(info, token, want, 0);
453 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
__anon99ebcc580302(const std::shared_ptr<AbilityRuntime::Context> &) 454 auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
455 bool isAsyncCallback = false;
456 ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
457 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0300 end.";
458 }
459
460 /*
461 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0400
462 * @tc.name: AddAbilityStage
463 * @tc.desc: Verify function AddAbilityStage abilityRecord->GetWant() not empty
464 */
465 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0400, TestSize.Level1)
466 {
467 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0400 start.";
468 std::shared_ptr<AbilityInfo> info = std::make_shared<AbilityInfo>();
469 info->applicationInfo.multiProjects = true;
470 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
471 auto abilityRecord = std::make_shared<AbilityLocalRecord>(info, token, nullptr, 0);
__anon99ebcc580402(const std::shared_ptr<AbilityRuntime::Context> &) 472 auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
473 bool isAsyncCallback = false;
474 ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
475 EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
476 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0400 end.";
477 }
478
479 /*
480 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0500
481 * @tc.name: AddAbilityStage
482 * @tc.desc: Verify function AddAbilityStage pointer abilityStages not empty
483 */
484 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0500, TestSize.Level1)
485 {
486 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0500 start.";
487 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
488 std::shared_ptr<AbilityInfo> info = nullptr;
489 std::string moduleName = "entry";
490 auto abilityRecord = std::make_shared<AbilityLocalRecord>(info, token, nullptr, 0);
491 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
492 std::shared_ptr<AbilityRuntime::AbilityStage> abilityStages = std::make_shared<AbilityRuntime::AbilityStage>();
493 ohosApplication_->abilityStages_.emplace(moduleName, abilityStages);
__anon99ebcc580502(const std::shared_ptr<AbilityRuntime::Context> &) 494 auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
495 bool isAsyncCallback = false;
496 ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
497 EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
498 EXPECT_TRUE(abilityStages != nullptr);
499 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0500 end.";
500 }
501
502 /*
503 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0600
504 * @tc.name: AddAbilityStage
505 * @tc.desc: Verify function AddAbilityStage pointer token empty
506 */
507 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0600, TestSize.Level1)
508 {
509 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0600 start.";
510 sptr<Notification::MockIRemoteObject> token;
511 std::shared_ptr<AbilityInfo> info = std::make_shared<AbilityInfo>();
512 info->moduleName = "entry";
513 auto abilityRecord = std::make_shared<AbilityLocalRecord>(info, token, nullptr, 0);
__anon99ebcc580602(const std::shared_ptr<AbilityRuntime::Context> &) 514 auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
515 bool isAsyncCallback = false;
516 ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
517 ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
518 EXPECT_TRUE(token == nullptr);
519 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0600 end.";
520 }
521
522 /*
523 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0700
524 * @tc.name: AddAbilityStage
525 * @tc.desc: Verify function AddAbilityStage pointer token not empty
526 */
527 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0700, TestSize.Level1)
528 {
529 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0700 start.";
530 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
531 std::shared_ptr<AbilityInfo> info = std::make_shared<AbilityInfo>();
532 auto abilityRecord = std::make_shared<AbilityLocalRecord>(info, token, nullptr, 0);
533 abilityRecord->token_ = new (std::nothrow) Notification::MockIRemoteObject();
__anon99ebcc580702(const std::shared_ptr<AbilityRuntime::Context> &) 534 auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
535 bool isAsyncCallback = false;
536 ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
537 EXPECT_TRUE(token != nullptr);
538 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0700 end.";
539 }
540
541 /*
542 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0800
543 * @tc.name: AddAbilityStage
544 * @tc.desc: Verify function AddAbilityStage pointer abilityRuntimeContext_ empty
545 */
546 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0800, TestSize.Level1)
547 {
548 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0800 start.";
549 HapModuleInfo hapModuleInfo;
__anon99ebcc580802() 550 auto callback = []() {};
551 bool isAsyncCallback = false;
552 ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
553 EXPECT_TRUE(ohosApplication_->abilityRuntimeContext_ == nullptr);
554 EXPECT_FALSE(ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback));
555 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0800 end.";
556 }
557
558 /*
559 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0900
560 * @tc.name: AddAbilityStage
561 * @tc.desc: Verify function AddAbilityStage pointer runtime_ empty
562 */
563 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0900, TestSize.Level1)
564 {
565 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0900 start.";
566 HapModuleInfo hapModuleInfo;
__anon99ebcc580902() 567 auto callback = []() {};
568 bool isAsyncCallback = false;
569 ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
570 ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
571 EXPECT_TRUE(ohosApplication_->runtime_ == nullptr);
572 EXPECT_FALSE(ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback));
573 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0900 end.";
574 }
575
576 /*
577 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_01000
578 * @tc.name: AddAbilityStage
579 * @tc.desc: Verify function AddAbilityStage map abilityStages_ not empty
580 */
581 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_01000, TestSize.Level1)
582 {
583 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01000 start.";
584 HapModuleInfo hapModuleInfo;
__anon99ebcc580a02() 585 auto callback = []() {};
586 bool isAsyncCallback = false;
587 std::string moduleName = "entry";
588 ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
589 std::shared_ptr<AbilityRuntime::AbilityStage> abilityStages = std::make_shared<AbilityRuntime::AbilityStage>();
590 ohosApplication_->abilityStages_.emplace(moduleName, abilityStages);
591 ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
592 ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
593 EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
594 EXPECT_FALSE(ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback));
595 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01000 end.";
596 }
597
598 /*
599 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_01100
600 * @tc.name: AddAbilityStage
601 * @tc.desc: Verify function AddAbilityStage variable moduleInfo empty
602 */
603 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_01100, TestSize.Level1)
604 {
605 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01100 start.";
606 HapModuleInfo hapModuleInfo;
__anon99ebcc580b02() 607 auto callback = []() {};
608 bool isAsyncCallback = false;
609 ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
610 ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
611 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
612 ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
613 ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
614 auto contextImpl = std::make_shared<AbilityRuntime::ContextImpl>();
615 auto appInfo = std::make_shared<ApplicationInfo>();
616 appInfo->multiProjects = true;
617 contextImpl->SetApplicationInfo(appInfo);
618 ohosApplication_->abilityRuntimeContext_->AttachContextImpl(contextImpl);
619 ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
620 EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
621 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01100 end.";
622 }
623
624 /*
625 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_01200
626 * @tc.name: AddAbilityStage
627 * @tc.desc: Verify function AddAbilityStage abilityRuntimeContext_->GetApplicationInfo() true
628 */
629 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_01200, TestSize.Level1)
630 {
631 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01200 start.";
632 HapModuleInfo hapModuleInfo;
__anon99ebcc580c02() 633 auto callback = []() {};
634 bool isAsyncCallback = false;
635 ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
636 ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
637 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
638 ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
639 ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
640 auto contextImpl = std::make_shared<AbilityRuntime::ContextImpl>();
641 auto appInfo = std::make_shared<ApplicationInfo>();
642 appInfo->multiProjects = false;
643 contextImpl->SetApplicationInfo(appInfo);
644 ohosApplication_->abilityRuntimeContext_->AttachContextImpl(contextImpl);
645 ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
646 EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
647 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01200 end.";
648 }
649
650 /*
651 * @tc.number: AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0100
652 * @tc.name: CleanAbilityStage
653 * @tc.desc: Verify function CleanAbilityStage pointer abilityInfo empty
654 */
655 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0100, TestSize.Level1)
656 {
657 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0100 start.";
658 std::shared_ptr<AbilityInfo> abilityInfo = nullptr;
659 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
660 ohosApplication_->CleanAbilityStage(token, abilityInfo, false);
661 EXPECT_TRUE(abilityInfo == nullptr);
662 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0100 end.";
663 }
664
665 /*
666 * @tc.number: AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0200
667 * @tc.name: CleanAbilityStage
668 * @tc.desc: Verify function CleanAbilityStage pointer token empty
669 */
670 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0200, TestSize.Level1)
671 {
672 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0200 start.";
673 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
674 sptr<Notification::MockIRemoteObject> token = nullptr;
675 ohosApplication_->CleanAbilityStage(token, abilityInfo, false);
676 EXPECT_TRUE(token == nullptr);
677 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0200 end.";
678 }
679
680 /*
681 * @tc.number: AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0300
682 * @tc.name: CleanAbilityStage
683 * @tc.desc: Verify function CleanAbilityStage map abilityRecords_ not empty
684 */
685 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0300, TestSize.Level1)
686 {
687 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0300 start.";
688 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
689 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
690 abilityInfo->moduleName = "entry";
691 std::shared_ptr<AbilityRuntime::AbilityStage> abilityStage = std::make_shared<AbilityRuntime::AbilityStage>();
692 sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
693 ohosApplication_->abilityStages_.emplace(abilityInfo->moduleName, abilityStage);
694 EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
695 ohosApplication_->CleanAbilityStage(token, abilityInfo, false);
696 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
697 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0300 end.";
698 }
699
700 /*
701 * @tc.number: AppExecFwk_OHOSApplicationTest_GetAppContext_0100
702 * @tc.name: GetAppContext
703 * @tc.desc: Verify function GetAppContext pointer token empty
704 */
705 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_GetAppContext_0100, TestSize.Level1)
706 {
707 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetAppContext_0100 start.";
708 auto context = ohosApplication_->GetAppContext();
709 EXPECT_TRUE(context == nullptr);
710 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetAppContext_0100 end.";
711 }
712
713 /*
714 * @tc.number: AppExecFwk_OHOSApplicationTest_GetRuntime_0100
715 * @tc.name: GetRuntime
716 * @tc.desc: Verify function GetRuntime pointer token empty
717 */
718 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_GetRuntime_0100, TestSize.Level1)
719 {
720 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetRuntime_0100 start.";
721 auto &runtime = ohosApplication_->GetRuntime();
722 EXPECT_TRUE(runtime == nullptr);
723 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetRuntime_0100 end.";
724 }
725
726 /*
727 * @tc.number: AppExecFwk_OHOSApplicationTest_SetConfiguration_0100
728 * @tc.name: SetConfiguration
729 * @tc.desc: Verify function SetConfiguration pointer token empty
730 */
731 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetConfiguration_0100, TestSize.Level1)
732 {
733 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetConfiguration_0100 start.";
734 Configuration config;
735 ohosApplication_->configuration_ = nullptr;
736 ohosApplication_->SetConfiguration(config);
737 ohosApplication_->SetConfiguration(config);
738 EXPECT_TRUE(ohosApplication_->configuration_ != nullptr);
739 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetConfiguration_0100 end.";
740 }
741
742 /*
743 * @tc.number: AppExecFwk_OHOSApplicationTest_ScheduleAcceptWant_0100
744 * @tc.name: ScheduleAcceptWant
745 * @tc.desc: Verify function ScheduleAcceptWant pointer abilityStage not empty
746 */
747 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_ScheduleAcceptWant_0100, TestSize.Level1)
748 {
749 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_ScheduleAcceptWant_0100 start.";
750 Want want;
751 std::string flag = "";
752 std::string moduleName = "entry";
753 EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
754 std::shared_ptr<AbilityRuntime::AbilityStage> abilityStage = std::make_shared<AbilityRuntime::AbilityStage>();
755 ohosApplication_->abilityStages_.emplace(moduleName, abilityStage);
756 EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
757 ohosApplication_->ScheduleAcceptWant(want, moduleName, flag);
758 EXPECT_TRUE(abilityStage != nullptr);
759 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_ScheduleAcceptWant_0100 end.";
760 }
761
762 /*
763 * @tc.number: AppExecFwk_OHOSApplicationTest_GetConfiguration_0100
764 * @tc.name: GetConfiguration
765 * @tc.desc: Verify function GetConfiguration pointer configuration_ not empty
766 */
767 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_GetConfiguration_0100, TestSize.Level1)
768 {
769 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetConfiguration_0100 start.";
770 Configuration config;
771 ohosApplication_->configuration_ = nullptr;
772 ohosApplication_->GetConfiguration();
773 EXPECT_TRUE(ohosApplication_->configuration_ == nullptr);
774 ohosApplication_->SetConfiguration(config);
775 ohosApplication_->GetConfiguration();
776 EXPECT_TRUE(ohosApplication_->configuration_ != nullptr);
777 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetConfiguration_0100 end.";
778 }
779
780 /*
781 * @tc.number: AppExecFwk_OHOSApplicationTest_SetExtensionTypeMap_0100
782 * @tc.name: SetExtensionTypeMap
783 * @tc.desc: Verify function SetExtensionTypeMap map extensionTypeMap_ not empty
784 */
785 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetExtensionTypeMap_0100, TestSize.Level1)
786 {
787 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetExtensionTypeMap_0100 start.";
788 const std::string name = "entry";
789 constexpr int32_t id = 1;
790 std::map<int32_t, std::string> map;
791 map.emplace(id, name);
792 ohosApplication_->SetExtensionTypeMap(map);
793 EXPECT_FALSE(ohosApplication_->extensionTypeMap_.empty());
794 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetExtensionTypeMap_0100 end.";
795 }
796
797 /*
798 * @tc.number: AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0100
799 * @tc.name: NotifyLoadRepairPatch
800 * @tc.desc: Verify function NotifyLoadRepairPatch pointer runtime_ empty
801 */
802 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0100, TestSize.Level1)
803 {
804 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0100 start.";
805 const std::string hqfFile = "hqfFile";
806 const std::string hapPat = "hapPat";
807 EXPECT_TRUE(ohosApplication_->NotifyLoadRepairPatch(hqfFile, hapPat));
808 EXPECT_TRUE(ohosApplication_->runtime_ == nullptr);
809 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0100 end.";
810 }
811
812 /*
813 * @tc.number: AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0200
814 * @tc.name: NotifyLoadRepairPatch
815 * @tc.desc: Verify function NotifyLoadRepairPatch function LoadRepairPatch called
816 */
817 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0200, TestSize.Level1)
818 {
819 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0200 start.";
820 const std::string hqfFile = "hqfFile";
821 const std::string hapPath = "hapPath";
822 ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
823 ohosApplication_->NotifyLoadRepairPatch(hqfFile, hapPath);
824 EXPECT_TRUE(ohosApplication_->runtime_ != nullptr);
825 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0200 end.";
826 }
827
828 /*
829 * @tc.number: AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0100
830 * @tc.name: NotifyHotReloadPage
831 * @tc.desc: Verify function NotifyHotReloadPage pointer runtime_ empty
832 */
833 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0100, TestSize.Level1)
834 {
835 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0100 start.";
836 ohosApplication_->NotifyHotReloadPage();
837 EXPECT_TRUE(ohosApplication_->runtime_ == nullptr);
838 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0100 end.";
839 }
840
841 /*
842 * @tc.number: AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0200
843 * @tc.name: NotifyHotReloadPage
844 * @tc.desc: Verify function NotifyHotReloadPage pointer runtime_ not empty
845 */
846 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0200, TestSize.Level1)
847 {
848 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0200 start.";
849 ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
850 ohosApplication_->NotifyHotReloadPage();
851 EXPECT_TRUE(ohosApplication_->runtime_ != nullptr);
852 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0200 end.";
853 }
854
855 /*
856 * @tc.number: AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0100
857 * @tc.name: NotifyUnLoadRepairPatch
858 * @tc.desc: Verify function NotifyHotReloadPage pointer runtime_ empty
859 */
860 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0100, TestSize.Level1)
861 {
862 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0100 start.";
863 std::string hqfFile = "hqfFile";
864 ohosApplication_->NotifyUnLoadRepairPatch(hqfFile);
865 EXPECT_TRUE(ohosApplication_->runtime_ == nullptr);
866 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0100 end.";
867 }
868
869 /*
870 * @tc.number: AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0200
871 * @tc.name: NotifyUnLoadRepairPatch
872 * @tc.desc: Verify function NotifyHotReloadPage pointer runtime_ not empty
873 */
874 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0200, TestSize.Level1)
875 {
876 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0200 start.";
877 ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
878 std::string hqfFile = "entry";
879 ohosApplication_->NotifyUnLoadRepairPatch(hqfFile);
880 EXPECT_TRUE(ohosApplication_->runtime_ != nullptr);
881 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0200 end.";
882 }
883
884 /*
885 * @tc.number: AppExecFwk_OHOSApplicationTest_SetAppEnv_0100
886 * @tc.name: SetAppEnv
887 * @tc.desc: Verify SetAppEnv function
888 */
889 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetAppEnv_0100, TestSize.Level1)
890 {
891 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAppEnv_0100 start.";
892 AppEnvironment appEnvironment;
893 appEnvironment.name = "env_key_demo";
894 appEnvironment.value = "env_value_demo";
895 std::vector<AppEnvironment> appEnvironments = {appEnvironment};
896 ohosApplication_->SetAppEnv(appEnvironments);
897 std::string appEnvVal = getenv(appEnvironment.name.c_str());
898 EXPECT_EQ(appEnvVal, appEnvironment.value);
899 GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAppEnv_0100 end.";
900 }
901 } // namespace AppExecFwk
902 } // namespace OHOS
903