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_ability_lifecycle_callbacks.h"
29 #include "mock_element_callback.h"
30 #include "mock_i_remote_object.h"
31 #include "mock_runtime.h"
32 #include "ohos_application.h"
33 #include "pac_map.h"
34 #include "resource_manager.h"
35 #include "runtime.h"
36 #include "ui_ability.h"
37 #undef private
38 
39 using namespace testing;
40 using namespace testing::ext;
41 
42 namespace OHOS {
43 namespace AppExecFwk {
44 class OHOSApplicationTest : public testing::Test {
45 public:
46     static void SetUpTestCase();
47     static void TearDownTestCase();
48     void SetUp() override;
49     void TearDown() override;
50     std::shared_ptr<OHOSApplication> ohosApplication_;
51 };
52 
SetUpTestCase()53 void OHOSApplicationTest::SetUpTestCase()
54 {}
55 
TearDownTestCase()56 void OHOSApplicationTest::TearDownTestCase()
57 {}
58 
SetUp()59 void OHOSApplicationTest::SetUp()
60 {
61     ohosApplication_ = std::make_shared<OHOSApplication>();
62 }
63 
TearDown()64 void OHOSApplicationTest::TearDown()
65 {
66     ohosApplication_ = nullptr;
67 }
68 
69 /*
70 * @tc.number: AppExecFwk_OHOSApplicationTest_DispatchAbilitySavedState_0100
71 * @tc.name: DispatchAbilitySavedState
72 * @tc.desc: Verify function DispatchAbilitySavedState list abilityLifecycleCallbacks_ empty
73 */
74 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_DispatchAbilitySavedState_0100, TestSize.Level1)
75 {
76     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DispatchAbilitySavedState_0100 start.";
77     PacMap outState;
78     ohosApplication_->DispatchAbilitySavedState(outState);
79     EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty());
80     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DispatchAbilitySavedState_0100 end.";
81 }
82 
83 /*
84 * @tc.number: AppExecFwk_OHOSApplicationTest_DispatchAbilitySavedState_0200
85 * @tc.name: DispatchAbilitySavedState
86 * @tc.desc: Verify function DispatchAbilitySavedState list abilityLifecycleCallbacks_ not empty
87 */
88 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_DispatchAbilitySavedState_0200, TestSize.Level1)
89 {
90     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DispatchAbilitySavedState_0200 start.";
91     PacMap outState;
92     std::shared_ptr<MockAbilityLifecycleCallbacks> abilityLifecycleCallbacks =
93         std::make_shared<MockAbilityLifecycleCallbacks>();
94     EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty());
95     ohosApplication_->abilityLifecycleCallbacks_.emplace_back(abilityLifecycleCallbacks);
96     ohosApplication_->DispatchAbilitySavedState(outState);
97     EXPECT_TRUE(!ohosApplication_->abilityLifecycleCallbacks_.empty());
98     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DispatchAbilitySavedState_0200 end.";
99 }
100 
101 /*
102 * @tc.number: AppExecFwk_OHOSApplicationTest_OnForeground_0100
103 * @tc.name: OnForeground
104 * @tc.desc: Verify function OnForeground pointer runtime_  empty
105 */
106 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnForeground_0100, TestSize.Level1)
107 {
108     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnForeground_0100 start.";
109     ohosApplication_->OnForeground();
110     EXPECT_TRUE(ohosApplication_->runtime_ == nullptr);
111     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnForeground_0100 end.";
112 }
113 
114 /*
115 * @tc.number: AppExecFwk_OHOSApplicationTest_OnForeground_0200
116 * @tc.name: OnForeground
117 * @tc.desc: Verify function OnForeground pointer runtime_ not empty
118 */
119 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnForeground_0200, TestSize.Level1)
120 {
121     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnForeground_0200 start.";
122     ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
123     ohosApplication_->OnForeground();
124     EXPECT_TRUE(ohosApplication_->runtime_ != nullptr);
125     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnForeground_0200 end.";
126 }
127 
128 /*
129 * @tc.number: AppExecFwk_OHOSApplicationTest_OnBackground_0100
130 * @tc.name: OnBackground
131 * @tc.desc: Verify function OnBackground pointer runtime_ empty
132 */
133 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnBackground_0100, TestSize.Level1)
134 {
135     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnBackground_0100 start.";
136     ohosApplication_->OnBackground();
137     EXPECT_TRUE(ohosApplication_->runtime_ == nullptr);
138     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnBackground_0100 end.";
139 }
140 
141 /*
142 * @tc.number: AppExecFwk_OHOSApplicationTest_OnBackground_0200
143 * @tc.name: OnBackground
144 * @tc.desc: Verify function OnBackground pointer runtime_ not empty
145 */
146 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnBackground_0200, TestSize.Level1)
147 {
148     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnBackground_0200 start.";
149     ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
150     ohosApplication_->OnBackground();
151     EXPECT_TRUE(ohosApplication_->runtime_ != nullptr);
152     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnBackground_0200 end.";
153 }
154 
155 /*
156 * @tc.number: AppExecFwk_OHOSApplicationTest_DumpApplication_0100
157 * @tc.name: DumpApplication
158 * @tc.desc: Verify function DumpApplication pointer record not empty
159 */
160 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_DumpApplication_0100, TestSize.Level1)
161 {
162     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DumpApplication_0100 start.";
163     ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
164     sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
165     std::shared_ptr<AbilityInfo> info = nullptr;
166     std::shared_ptr<AbilityLocalRecord> record = std::make_shared<AbilityLocalRecord>(info, token);
167     ohosApplication_->abilityRecordMgr_->abilityRecords_.emplace(token, record);
168     ohosApplication_->DumpApplication();
169     EXPECT_TRUE(record != nullptr);
170     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DumpApplication_0100 end.";
171 }
172 
173 /*
174 * @tc.number: AppExecFwk_OHOSApplicationTest_DumpApplication_0200
175 * @tc.name: DumpApplication
176 * @tc.desc: Verify function DumpApplication pointer abilityInfo not empty
177 */
178 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_DumpApplication_0200, TestSize.Level1)
179 {
180     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DumpApplication_0200 start.";
181     ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
182     sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
183     std::shared_ptr<AbilityInfo> info = std::make_shared<AbilityInfo>();
184     std::shared_ptr<AbilityLocalRecord> record =  std::make_shared<AbilityLocalRecord>(info, token);
185     info->permissions.push_back(std::string("abc"));
186     ohosApplication_->abilityRecordMgr_->abilityRecords_.emplace(token, record);
187     ohosApplication_->DumpApplication();
188     EXPECT_TRUE(record != nullptr);
189     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DumpApplication_0200 end.";
190 }
191 
192 /*
193 * @tc.number: AppExecFwk_OHOSApplicationTest_DumpApplication_0300
194 * @tc.name: DumpApplication
195 * @tc.desc: Verify function DumpApplication pointer applicationInfoPtr not empty
196 */
197 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_DumpApplication_0300, TestSize.Level1)
198 {
199     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DumpApplication_0300 start.";
200     ohosApplication_->DumpApplication();
201     auto contextDeal = std::make_shared<ContextDeal>();
202     auto appInfo = std::make_shared<ApplicationInfo>();
203     contextDeal->SetApplicationInfo(appInfo);
204     ohosApplication_->AttachBaseContext(contextDeal);
205     ohosApplication_->DumpApplication();
206     EXPECT_TRUE(ohosApplication_->GetApplicationInfo() != nullptr);
207     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_DumpApplication_0300 end.";
208 }
209 
210 /*
211 * @tc.number: AppExecFwk_OHOSApplicationTest_SetRuntime_0100
212 * @tc.name: SetRuntime
213 * @tc.desc: Verify function SetRuntime pointer runtime empty
214 */
215 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetRuntime_0100, TestSize.Level1)
216 {
217     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetRuntime_0100 start.";
218     std::unique_ptr<AbilityRuntime::Runtime> runtime = nullptr;
219     ohosApplication_->SetRuntime(std::move(runtime));
220     EXPECT_TRUE(runtime == nullptr);
221     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetRuntime_0100 end.";
222 }
223 
224 /*
225 * @tc.number: AppExecFwk_OHOSApplicationTest_SetRuntime_0200
226 * @tc.name: SetRuntime
227 * @tc.desc: Verify function SetRuntime pointer runtime_ not empty
228 */
229 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetRuntime_0200, TestSize.Level1)
230 {
231     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetRuntime_0200 start.";
232     std::unique_ptr<AbilityRuntime::Runtime> runtime = std::make_unique<AbilityRuntime::MockRuntime>();
233     EXPECT_TRUE(runtime != nullptr);
234     ohosApplication_->SetRuntime(std::move(runtime));
235     EXPECT_TRUE(ohosApplication_->runtime_ != nullptr);
236     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetRuntime_0200 end.";
237 }
238 
239 /*
240 * @tc.number: AppExecFwk_OHOSApplicationTest_SetApplicationContext_0100
241 * @tc.name: SetApplicationContext
242 * @tc.desc: Verify function SetApplicationContext pointer abilityRuntimeContext_ empty
243 */
244 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetApplicationContext_0100, TestSize.Level1)
245 {
246     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0100 start.";
247     std::shared_ptr<AbilityRuntime::ApplicationContext> abilityRuntimeContext = nullptr;
248     ohosApplication_->SetApplicationContext(abilityRuntimeContext);
249     EXPECT_TRUE(ohosApplication_->abilityRuntimeContext_ == nullptr);
250     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0100 end.";
251 }
252 
253 /*
254 * @tc.number: AppExecFwk_OHOSApplicationTest_SetApplicationContext_0200
255 * @tc.name: SetApplicationContext
256 * @tc.desc: Verify function SetApplicationContext pointer abilityRuntimeContext_ not empty
257 */
258 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetApplicationContext_0200, TestSize.Level1)
259 {
260     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0200 start.";
261     std::shared_ptr<AbilityRuntime::ApplicationContext> abilityRuntimeContext =
262         std::make_shared<AbilityRuntime::ApplicationContext>();
263     EXPECT_TRUE(abilityRuntimeContext != nullptr);
264     ohosApplication_->SetApplicationContext(abilityRuntimeContext);
265     EXPECT_TRUE(ohosApplication_->abilityRuntimeContext_ != nullptr);
266     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetApplicationContext_0200 end.";
267 }
268 
269 /*
270 * @tc.number: AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0100
271 * @tc.name: SetAbilityRecordMgr
272 * @tc.desc: Verify function SetAbilityRecordMgr pointer abilityRecordMgr_ empty
273 */
274 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0100, TestSize.Level1)
275 {
276     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0100 start.";
277     std::shared_ptr<AbilityRecordMgr> abilityRecordMgr = nullptr;
278     ohosApplication_->SetAbilityRecordMgr(abilityRecordMgr);
279     EXPECT_TRUE(ohosApplication_->abilityRecordMgr_ == nullptr);
280     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0100 end.";
281 }
282 
283 /*
284 * @tc.number: AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0200
285 * @tc.name: SetAbilityRecordMgr
286 * @tc.desc: Verify function SetAbilityRecordMgr pointer abilityRecordMgr_ not empty
287 */
288 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0200, TestSize.Level1)
289 {
290     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0200 start.";
291     std::shared_ptr<AbilityRecordMgr> abilityRecordMgr = std::make_shared<AbilityRecordMgr>();
292     EXPECT_TRUE(abilityRecordMgr != nullptr);
293     ohosApplication_->SetAbilityRecordMgr(abilityRecordMgr);
294     EXPECT_TRUE(ohosApplication_->abilityRecordMgr_ != nullptr);
295     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAbilityRecordMgr_0200 end.";
296 }
297 
298 /*
299 * @tc.number: AppExecFwk_OHOSApplicationTest_RegisterAbilityLifecycleCallbacks_0100
300 * @tc.name: RegisterAbilityLifecycleCallbacks
301 * @tc.desc: Verify function RegisterAbilityLifecycleCallbacks list abilityLifecycleCallbacks_ empty
302 */
303 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_RegisterAbilityLifecycleCallbacks_0100, TestSize.Level1)
304 {
305     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_RegisterAbilityLifecycleCallbacks_0100 start.";
306     std::shared_ptr<MockAbilityLifecycleCallbacks> callBack = nullptr;
307     EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty());
308     ohosApplication_->RegisterAbilityLifecycleCallbacks(callBack);
309     EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty());
310     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_RegisterAbilityLifecycleCallbacks_0100 end.";
311 }
312 
313 /*
314 * @tc.number: AppExecFwk_OHOSApplicationTest_RegisterAbilityLifecycleCallbacks_0200
315 * @tc.name: RegisterAbilityLifecycleCallbacks
316 * @tc.desc: Verify function RegisterAbilityLifecycleCallbacks list abilityLifecycleCallbacks_ not empty
317 */
318 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_RegisterAbilityLifecycleCallbacks_0200, TestSize.Level1)
319 {
320     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_RegisterAbilityLifecycleCallbacks_0200 start.";
321     EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty());
322     std::shared_ptr<MockAbilityLifecycleCallbacks> callBack = std::make_shared<MockAbilityLifecycleCallbacks>();
323     ohosApplication_->RegisterAbilityLifecycleCallbacks(callBack);
324     EXPECT_FALSE(ohosApplication_->abilityLifecycleCallbacks_.empty());
325     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_RegisterAbilityLifecycleCallbacks_0200 end.";
326 }
327 
328 /*
329 * @tc.number: AppExecFwk_OHOSApplicationTest_UnregisterAbilityLifecycleCallbacks_0100
330 * @tc.name: UnregisterAbilityLifecycleCallbacks
331 * @tc.desc: Verify function UnregisterAbilityLifecycleCallbacks list abilityLifecycleCallbacks_ empty
332 */
333 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_UnregisterAbilityLifecycleCallbacks_0100, TestSize.Level1)
334 {
335     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_UnregisterAbilityLifecycleCallbacks_0100 start.";
336     EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty());
337     std::shared_ptr<MockAbilityLifecycleCallbacks> callBack = nullptr;
338     ohosApplication_->UnregisterAbilityLifecycleCallbacks(callBack);
339     EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty());
340     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_UnregisterAbilityLifecycleCallbacks_0100 end.";
341 }
342 
343 /*
344 * @tc.number: AppExecFwk_OHOSApplicationTest_UnregisterAbilityLifecycleCallbacks_0200
345 * @tc.name: UnregisterAbilityLifecycleCallbacks
346 * @tc.desc: Verify function UnregisterAbilityLifecycleCallbacks list abilityLifecycleCallbacks_ not empty
347 */
348 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_UnregisterAbilityLifecycleCallbacks_0200, TestSize.Level1)
349 {
350     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_UnregisterAbilityLifecycleCallbacks_0200 start.";
351     EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty());
352     std::shared_ptr<MockAbilityLifecycleCallbacks> callBack = std::make_shared<MockAbilityLifecycleCallbacks>();
353     ohosApplication_->abilityLifecycleCallbacks_.emplace_back(callBack);
354     EXPECT_FALSE(ohosApplication_->abilityLifecycleCallbacks_.empty());
355     ohosApplication_->UnregisterAbilityLifecycleCallbacks(callBack);
356     EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty());
357     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_UnregisterAbilityLifecycleCallbacks_0200 end.";
358 }
359 
360 /*
361 * @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityStart_0100
362 * @tc.name: OnAbilityStart
363 * @tc.desc: Verify function OnAbilityStart pointer ability empty
364 */
365 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityStart_0100, TestSize.Level1)
366 {
367     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityStart_0100 start.";
368     std::shared_ptr<AbilityRuntime::UIAbility> ability = nullptr;
369     EXPECT_TRUE(ability == nullptr);
370     ohosApplication_->OnAbilityStart(ability);
371     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityStart_0100 end.";
372 }
373 
374 /*
375 * @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityStart_0200
376 * @tc.name: OnAbilityStart
377 * @tc.desc: Verify function OnAbilityStart pointer abilityLifecycleCallbacks_ not empty
378 */
379 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityStart_0200, TestSize.Level1)
380 {
381     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityStart_0200 start.";
382     std::shared_ptr<AbilityRuntime::UIAbility> ability = std::make_shared<AbilityRuntime::UIAbility>();
383     EXPECT_TRUE(ability != nullptr);
384     ohosApplication_->OnAbilityStart(ability);
385     EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty());
386     std::shared_ptr<MockAbilityLifecycleCallbacks> callback1 = std::make_shared<MockAbilityLifecycleCallbacks>();
387     std::shared_ptr<MockAbilityLifecycleCallbacks> callback2 = nullptr;
388     ohosApplication_->abilityLifecycleCallbacks_.emplace_back(callback1);
389     ohosApplication_->abilityLifecycleCallbacks_.emplace_back(callback2);
390     ohosApplication_->OnAbilityStart(ability);
391     EXPECT_FALSE(ohosApplication_->abilityLifecycleCallbacks_.empty());
392     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityStart_0200 end.";
393 }
394 
395 /*
396 * @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityInactive_0100
397 * @tc.name: OnAbilityInactive
398 * @tc.desc: Verify function OnAbilityInactive pointer ability empty
399 */
400 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityInactive_0100, TestSize.Level1)
401 {
402     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityInactive_0100 start.";
403     std::shared_ptr<AbilityRuntime::UIAbility> ability = nullptr;
404     ohosApplication_->OnAbilityInactive(ability);
405     EXPECT_TRUE(ability == nullptr);
406     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityInactive_0100 end.";
407 }
408 
409 /*
410 * @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityInactive_0200
411 * @tc.name: OnAbilityInactive
412 * @tc.desc: Verify function OnAbilityInactive pointer abilityLifecycleCallbacks_ not empty
413 */
414 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityInactive_0200, TestSize.Level1)
415 {
416     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityInactive_0200 start.";
417     std::shared_ptr<AbilityRuntime::UIAbility> ability = std::make_shared<AbilityRuntime::UIAbility>();
418     EXPECT_TRUE(ability != nullptr);
419     ohosApplication_->OnAbilityInactive(ability);
420     EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty());
421     std::shared_ptr<MockAbilityLifecycleCallbacks> callback1 = std::make_shared<MockAbilityLifecycleCallbacks>();
422     std::shared_ptr<MockAbilityLifecycleCallbacks> callback2 = nullptr;
423     ohosApplication_->abilityLifecycleCallbacks_.emplace_back(callback1);
424     ohosApplication_->abilityLifecycleCallbacks_.emplace_back(callback2);
425     ohosApplication_->OnAbilityInactive(ability);
426     EXPECT_FALSE(ohosApplication_->abilityLifecycleCallbacks_.empty());
427     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityInactive_0200 end.";
428 }
429 
430 /*
431 * @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityBackground_0100
432 * @tc.name: OnAbilityBackground
433 * @tc.desc: Verify function OnAbilityBackground pointer ability empty
434 */
435 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityBackground_0100, TestSize.Level1)
436 {
437     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityBackground_0100 start.";
438     std::shared_ptr<AbilityRuntime::UIAbility> ability = nullptr;
439     ohosApplication_->OnAbilityBackground(ability);
440     EXPECT_TRUE(ability == nullptr);
441     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityBackground_0100 end.";
442 }
443 
444 /*
445 * @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityBackground_0200
446 * @tc.name: OnAbilityBackground
447 * @tc.desc: Verify function OnAbilityBackground pointer abilityLifecycleCallbacks_ not empty
448 */
449 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityBackground_0200, TestSize.Level1)
450 {
451     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityBackground_0200 start.";
452     std::shared_ptr<AbilityRuntime::UIAbility> ability = std::make_shared<AbilityRuntime::UIAbility>();
453     EXPECT_TRUE(ability != nullptr);
454     ohosApplication_->OnAbilityBackground(ability);
455     EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty());
456     std::shared_ptr<MockAbilityLifecycleCallbacks> callback = std::make_shared<MockAbilityLifecycleCallbacks>();
457     ohosApplication_->abilityLifecycleCallbacks_.emplace_back(callback);
458     ohosApplication_->OnAbilityBackground(ability);
459     EXPECT_TRUE(!ohosApplication_->abilityLifecycleCallbacks_.empty());
460     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityBackground_0200 end.";
461 }
462 
463 /*
464 * @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityForeground_0100
465 * @tc.name: OnAbilityForeground
466 * @tc.desc: Verify function OnAbilityForeground pointer ability empty
467 */
468 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityForeground_0100, TestSize.Level1)
469 {
470     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityForeground_0100 start.";
471     std::shared_ptr<AbilityRuntime::UIAbility> ability = nullptr;
472     ohosApplication_->OnAbilityForeground(ability);
473     EXPECT_TRUE(ability == nullptr);
474     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityForeground_0100 end.";
475 }
476 
477 /*
478 * @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityForeground_0200
479 * @tc.name: OnAbilityForeground
480 * @tc.desc: Verify function OnAbilityForeground pointer abilityLifecycleCallbacks_ not empty
481 */
482 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityForeground_0200, TestSize.Level1)
483 {
484     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityForeground_0200 start.";
485     std::shared_ptr<AbilityRuntime::UIAbility> ability = std::make_shared<AbilityRuntime::UIAbility>();
486     EXPECT_TRUE(ability != nullptr);
487     ohosApplication_->OnAbilityForeground(ability);
488     EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty());
489     std::shared_ptr<MockAbilityLifecycleCallbacks> callback = std::make_shared<MockAbilityLifecycleCallbacks>();
490     ohosApplication_->abilityLifecycleCallbacks_.emplace_back(callback);
491     ohosApplication_->OnAbilityForeground(ability);
492     EXPECT_TRUE(!ohosApplication_->abilityLifecycleCallbacks_.empty());
493     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityForeground_0200 end.";
494 }
495 
496 /*
497 * @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityActive_0100
498 * @tc.name: OnAbilityActive
499 * @tc.desc: Verify function OnAbilityActive pointer ability empty
500 */
501 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityActive_0100, TestSize.Level1)
502 {
503     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityActive_0100 start.";
504     std::shared_ptr<AbilityRuntime::UIAbility> ability = nullptr;
505     ohosApplication_->OnAbilityActive(ability);
506     EXPECT_TRUE(ability == nullptr);
507     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityActive_0100 end.";
508 }
509 
510 /*
511 * @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityActive_0200
512 * @tc.name: OnAbilityActive
513 * @tc.desc: Verify function OnAbilityActive pointer abilityLifecycleCallbacks_ not empty
514 */
515 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityActive_0200, TestSize.Level1)
516 {
517     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityActive_0200 start.";
518     std::shared_ptr<AbilityRuntime::UIAbility> ability = std::make_shared<AbilityRuntime::UIAbility>();
519     EXPECT_TRUE(ability != nullptr);
520     ohosApplication_->OnAbilityActive(ability);
521     EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty());
522     std::shared_ptr<MockAbilityLifecycleCallbacks> callback = std::make_shared<MockAbilityLifecycleCallbacks>();
523     ohosApplication_->abilityLifecycleCallbacks_.emplace_back(callback);
524     ohosApplication_->OnAbilityActive(ability);
525     EXPECT_TRUE(!ohosApplication_->abilityLifecycleCallbacks_.empty());
526     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityActive_0200 end.";
527 }
528 
529 /*
530 * @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityStop_0100
531 * @tc.name: OnAbilityStop
532 * @tc.desc: Verify function OnAbilityStop pointer ability empty
533 */
534 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityStop_0100, TestSize.Level1)
535 {
536     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityStop_0100 start.";
537     std::shared_ptr<AbilityRuntime::UIAbility> ability = nullptr;
538     ohosApplication_->OnAbilityStop(ability);
539     EXPECT_TRUE(ability == nullptr);
540     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityStop_0100 end.";
541 }
542 
543 /*
544 * @tc.number: AppExecFwk_OHOSApplicationTest_OnAbilityStop_0200
545 * @tc.name: OnAbilityStop
546 * @tc.desc: Verify function OnAbilityStop pointer abilityLifecycleCallbacks_ not empty
547 */
548 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnAbilityStop_0200, TestSize.Level1)
549 {
550     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityStop_0200 start.";
551     std::shared_ptr<AbilityRuntime::UIAbility> ability = std::make_shared<AbilityRuntime::UIAbility>();
552     EXPECT_TRUE(ability != nullptr);
553     ohosApplication_->OnAbilityStop(ability);
554     EXPECT_TRUE(ohosApplication_->abilityLifecycleCallbacks_.empty());
555     std::shared_ptr<MockAbilityLifecycleCallbacks> callback = std::make_shared<MockAbilityLifecycleCallbacks>();
556     ohosApplication_->abilityLifecycleCallbacks_.emplace_back(callback);
557     ohosApplication_->OnAbilityStop(ability);
558     EXPECT_TRUE(!ohosApplication_->abilityLifecycleCallbacks_.empty());
559     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnAbilityStop_0200 end.";
560 }
561 
562 /*
563 * @tc.number: AppExecFwk_OHOSApplicationTest_RegisterElementsCallbacks_0100
564 * @tc.name: RegisterElementsCallbacks
565 * @tc.desc: Verify function RegisterElementsCallbacks list elementsCallbacks_ empty
566 */
567 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_RegisterElementsCallbacks_0100, TestSize.Level1)
568 {
569     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_RegisterElementsCallbacks_0100 start.";
570     std::shared_ptr<MockElementsCallback> callback = nullptr;
571     EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty());
572     ohosApplication_->RegisterElementsCallbacks(callback);
573     EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty());
574     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_RegisterElementsCallbacks_0100 end.";
575 }
576 
577 /*
578 * @tc.number: AppExecFwk_OHOSApplicationTest_RegisterElementsCallbacks_0200
579 * @tc.name: RegisterElementsCallbacks
580 * @tc.desc: Verify function RegisterElementsCallbacks list elementsCallbacks_ not empty
581 */
582 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_RegisterElementsCallbacks_0200, TestSize.Level1)
583 {
584     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_RegisterElementsCallbacks_0200 start.";
585     std::shared_ptr<MockElementsCallback> callback = std::make_shared<MockElementsCallback>();
586     EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty());
587     ohosApplication_->RegisterElementsCallbacks(callback);
588     EXPECT_TRUE(!ohosApplication_->elementsCallbacks_.empty());
589     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_RegisterElementsCallbacks_0200 end.";
590 }
591 
592 /*
593 * @tc.number: AppExecFwk_OHOSApplicationTest_UnregisterElementsCallbacks_0100
594 * @tc.name: UnregisterElementsCallbacks
595 * @tc.desc: Verify function UnregisterElementsCallbacks list elementsCallbacks_ empty
596 */
597 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_UnregisterElementsCallbacks_0100, TestSize.Level1)
598 {
599     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_UnregisterElementsCallbacks_0100 start.";
600     std::shared_ptr<MockElementsCallback> callback = nullptr;
601     EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty());
602     ohosApplication_->UnregisterElementsCallbacks(callback);
603     EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty());
604     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_UnregisterElementsCallbacks_0100 end.";
605 }
606 
607 /*
608 * @tc.number: AppExecFwk_OHOSApplicationTest_UnregisterElementsCallbacks_0200
609 * @tc.name: UnregisterElementsCallbacks
610 * @tc.desc: Verify function UnregisterElementsCallbacks list elementsCallbacks_ not empty
611 */
612 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_UnregisterElementsCallbacks_0200, TestSize.Level1)
613 {
614     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_UnregisterElementsCallbacks_0200 start.";
615     std::shared_ptr<MockElementsCallback> callback = std::make_shared<MockElementsCallback>();
616     EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty());
617     ohosApplication_->elementsCallbacks_.emplace_back(callback);
618     EXPECT_FALSE(ohosApplication_->elementsCallbacks_.empty());
619     ohosApplication_->UnregisterElementsCallbacks(callback);
620     EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty());
621     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_UnregisterElementsCallbacks_0200 end.";
622 }
623 
624 /*
625 * @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0100
626 * @tc.name: OnConfigurationUpdated
627 * @tc.desc: Verify function OnConfigurationUpdated pointer abilityRecordMgr_ empty
628 */
629 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0100, TestSize.Level1)
630 {
631     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0100 start.";
632     Configuration config;
633     ohosApplication_->OnConfigurationUpdated(config);
634     EXPECT_TRUE(ohosApplication_->abilityRecordMgr_ == nullptr);
635     ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
636     ohosApplication_->OnConfigurationUpdated(config);
637     EXPECT_TRUE(ohosApplication_->configuration_ == nullptr);
638     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0100 end.";
639 }
640 
641 /*
642 * @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200
643 * @tc.name: OnConfigurationUpdated
644 * @tc.desc: Verify function OnConfigurationUpdated pointer abilityRecord not empty
645 */
646 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200, TestSize.Level1)
647 {
648     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200 start.";
649     Configuration config;
650     ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
651     ohosApplication_->configuration_ = std::make_shared<Configuration>();
652     sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
653     std::shared_ptr<AbilityInfo> info =  nullptr;
654     std::shared_ptr<AbilityLocalRecord> abilityRecord =  std::make_shared<AbilityLocalRecord>(info, token);
655     ohosApplication_->abilityRecordMgr_->abilityRecords_.emplace(token, abilityRecord);
656     sptr<AbilityThread> abilityThread = new (std::nothrow) AbilityRuntime::FAAbilityThread();
657     abilityRecord->SetAbilityThread(abilityThread);
658     ohosApplication_->OnConfigurationUpdated(config);
659     EXPECT_TRUE(!ohosApplication_->abilityRecordMgr_->abilityRecords_.empty());
660     EXPECT_TRUE(abilityRecord != nullptr);
661     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0200 end.";
662 }
663 
664 /*
665 * @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300
666 * @tc.name: OnConfigurationUpdated
667 * @tc.desc: Verify function OnConfigurationUpdated map abilityStages_ not empty
668 */
669 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300, TestSize.Level1)
670 {
671     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300 start.";
672     Configuration config;
673     ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
674     ohosApplication_->configuration_ = std::make_shared<Configuration>();
675     EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
676     std::string moduleName = "entry";
677     std::shared_ptr<AbilityRuntime::AbilityStage> abilityStages = std::make_shared<AbilityRuntime::AbilityStage>();
678     ohosApplication_->abilityStages_.emplace(moduleName, abilityStages);
679     ohosApplication_->OnConfigurationUpdated(config);
680     EXPECT_TRUE(!ohosApplication_->abilityStages_.empty());
681     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0300 end.";
682 }
683 
684 /*
685 * @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0400
686 * @tc.name: OnConfigurationUpdated
687 * @tc.desc: Verify function OnConfigurationUpdated variable configurationUpdated_ true
688 */
689 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0400, TestSize.Level1)
690 {
691     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0400 start.";
692     Configuration config;
693     ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
694     ohosApplication_->configuration_ = std::make_shared<Configuration>();
695     EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty());
696     std::shared_ptr<MockElementsCallback> callback = std::make_shared<MockElementsCallback>();
697     ohosApplication_->elementsCallbacks_.emplace_back(callback);
698     EXPECT_FALSE(callback->configurationUpdated_);
699     ohosApplication_->OnConfigurationUpdated(config);
700     EXPECT_TRUE(callback != nullptr);
701     EXPECT_FALSE(ohosApplication_->elementsCallbacks_.empty());
702     EXPECT_TRUE(callback->configurationUpdated_);
703     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0400 end.";
704 }
705 
706 /*
707 * @tc.number: AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0500
708 * @tc.name: OnConfigurationUpdated
709 * @tc.desc: Verify function OnConfigurationUpdated list elementsCallbacks_ empty
710 */
711 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0500, TestSize.Level1)
712 {
713     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0500 start.";
714     Configuration config;
715     ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
716     ohosApplication_->configuration_ = std::make_shared<Configuration>();
717     EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty());
718     ohosApplication_->OnConfigurationUpdated(config);
719     EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty());
720     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnConfigurationUpdated_0500 end.";
721 }
722 
723 /*
724 * @tc.number: OnConfigurationUpdated_0600
725 * @tc.name: OnConfigurationUpdated
726 * @tc.desc: Function test abilityRuntimeContext_ not empty
727 */
728 HWTEST_F(OHOSApplicationTest, OnConfigurationUpdated_0600, TestSize.Level1)
729 {
730     std::string bundleName = "test.bundleName";
731     std::string moduleName = "test.moduleName";
732     std::string hapPath = "/data/app/testHap";
733     std::vector<std::string> overlayPaths;
734     std::unique_ptr<Global::Resource::ResConfig> resConfigBefore(Global::Resource::CreateResConfig());
735     ASSERT_NE(resConfigBefore, nullptr);
736     std::shared_ptr<Global::Resource::ResourceManager> resourceManager(Global::Resource::CreateResourceManager(
737         bundleName, moduleName, hapPath, overlayPaths, *resConfigBefore));
738     ASSERT_NE(resourceManager, nullptr);
739     auto contextImpl = std::make_shared<AbilityRuntime::ContextImpl>();
740     contextImpl->SetResourceManager(resourceManager);
741 
742     auto appContext = std::make_shared<AbilityRuntime::ApplicationContext>();
743     appContext->AttachContextImpl(contextImpl);
744     ohosApplication_->SetApplicationContext(appContext);
745     ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
746     ohosApplication_->configuration_ = std::make_shared<Configuration>();
747 
748     Configuration config;
749     config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, "zh");
750     ohosApplication_->OnConfigurationUpdated(config);
751     std::unique_ptr<Global::Resource::ResConfig> resConfigAfter(Global::Resource::CreateResConfig());
752     ASSERT_NE(resConfigAfter, nullptr);
753     resourceManager->GetResConfig(*resConfigAfter);
754     const icu::Locale *localeInfo = resConfigAfter->GetLocaleInfo();
755     ASSERT_NE(localeInfo, nullptr);
756     TAG_LOGI(AAFwkTag::TEST, "Update config language %{public}s succeed.", localeInfo->getLanguage());
757     EXPECT_EQ(strcmp(localeInfo->getLanguage(), "zh"), 0);
758 }
759 
760 /*
761 * @tc.number: AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0100
762 * @tc.name: OnMemoryLevel
763 * @tc.desc: Verify function OnMemoryLevel pointer abilityRecord not empty
764 */
765 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0100, TestSize.Level1)
766 {
767     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0100 start.";
768     constexpr int32_t level = 1;
769     ohosApplication_->OnMemoryLevel(level);
770     ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
771     std::shared_ptr<AbilityInfo> info = nullptr;
772     sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
773     std::shared_ptr<AbilityLocalRecord> abilityRecord = std::make_shared<AbilityLocalRecord>(info, token);
774     EXPECT_TRUE(abilityRecord != nullptr);
775     ohosApplication_->abilityRecordMgr_->abilityRecords_.emplace(token, abilityRecord);
776     sptr<AbilityThread> abilityThread = new (std::nothrow) AbilityRuntime::FAAbilityThread();
777     abilityRecord->SetAbilityThread(abilityThread);
778     ohosApplication_->OnMemoryLevel(level);
779     EXPECT_FALSE(ohosApplication_->abilityRecordMgr_->abilityRecords_.empty());
780     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0100 end.";
781 }
782 
783 /*
784 * @tc.number: AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0200
785 * @tc.name: OnMemoryLevel
786 * @tc.desc: Verify function OnMemoryLevel map abilityStages_ not empty
787 */
788 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0200, TestSize.Level1)
789 {
790     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0200 start.";
791     constexpr int32_t level = 1;
792     ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
793     EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
794     std::string moduleName1 = "entry1";
795     std::string moduleName2 = "entry2";
796     std::shared_ptr<AbilityRuntime::AbilityStage> abilityStages1 = std::make_shared<AbilityRuntime::AbilityStage>();
797     std::shared_ptr<AbilityRuntime::AbilityStage> abilityStages2 = nullptr;
798     ohosApplication_->abilityStages_.emplace(moduleName1, abilityStages1);
799     ohosApplication_->abilityStages_.emplace(moduleName2, abilityStages2);
800     ohosApplication_->OnMemoryLevel(level);
801     EXPECT_TRUE(!ohosApplication_->abilityStages_.empty());
802     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0200 end.";
803 }
804 
805 /*
806 * @tc.number: AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0300
807 * @tc.name: OnMemoryLevel
808 * @tc.desc: Verify function OnMemoryLevel variable onMemoryLevel_ true
809 */
810 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0300, TestSize.Level1)
811 {
812     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0300 start.";
813     constexpr int32_t level = 1;
814     ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
815     EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty());
816     std::shared_ptr<MockElementsCallback> callback1 = std::make_shared<MockElementsCallback>();
817     std::shared_ptr<MockElementsCallback> callback2 = nullptr;
818     ohosApplication_->elementsCallbacks_.emplace_back(callback1);
819     ohosApplication_->elementsCallbacks_.emplace_back(callback2);
820     EXPECT_FALSE(callback1->onMemoryLevel_);
821     ohosApplication_->OnMemoryLevel(level);
822     EXPECT_FALSE(ohosApplication_->elementsCallbacks_.empty());
823     EXPECT_TRUE(callback1->onMemoryLevel_);
824     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0300 end.";
825 }
826 
827 /*
828 * @tc.number: AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0400
829 * @tc.name: OnMemoryLevel
830 * @tc.desc: Verify function OnMemoryLevel variable onMemoryLevel_ true
831 */
832 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0400, TestSize.Level1)
833 {
834     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0400 start.";
835     constexpr int32_t level = 1;
836     ohosApplication_->abilityRecordMgr_ = std::make_shared<AbilityRecordMgr>();
837     EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty());
838     ohosApplication_->OnMemoryLevel(level);
839     EXPECT_TRUE(ohosApplication_->elementsCallbacks_.empty());
840     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_OnMemoryLevel_0400 end.";
841 }
842 
843 /*
844 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0100
845 * @tc.name: AddAbilityStage
846 * @tc.desc: Verify function AddAbilityStage pointer abilityRecord empty
847 */
848 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0100, TestSize.Level1)
849 {
850     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0100 start.";
851     ohosApplication_->OnStart();
852     std::shared_ptr<AbilityLocalRecord> abilityRecord = nullptr;
__anonf594f9500102(const std::shared_ptr<AbilityRuntime::Context> &) 853     auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
854     bool isAsyncCallback = false;
855     ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
856     EXPECT_TRUE(abilityRecord == nullptr);
857     const PacMap outState;
858     ohosApplication_->OnAbilitySaveState(outState);
859     ohosApplication_->OnTerminate();
860     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0100 end.";
861 }
862 
863 /*
864 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0200
865 * @tc.name: AddAbilityStage
866 * @tc.desc: Verify function AddAbilityStage pointer abilityInfo empty
867 */
868 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0200, TestSize.Level1)
869 {
870     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0200 start.";
871     std::shared_ptr<AbilityLocalRecord> abilityRecord = nullptr;
872     std::shared_ptr<AbilityInfo> abilityInfo = nullptr;
__anonf594f9500202(const std::shared_ptr<AbilityRuntime::Context> &) 873     auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
874     bool isAsyncCallback = false;
875     ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
876     EXPECT_TRUE(abilityInfo == nullptr);
877     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0200 end.";
878 }
879 
880 /*
881 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0300
882 * @tc.name: AddAbilityStage
883 * @tc.desc: Verify function AddAbilityStage pointer hapModuleInfo empty
884 */
885 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0300, TestSize.Level1)
886 {
887     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0300 start.";
888     sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
889     std::shared_ptr<AbilityInfo> info = nullptr;
890     std::shared_ptr<AbilityLocalRecord> abilityRecord = std::make_shared<AbilityLocalRecord>(info, token);
891     EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
__anonf594f9500302(const std::shared_ptr<AbilityRuntime::Context> &) 892     auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
893     bool isAsyncCallback = false;
894     ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
895     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0300 end.";
896 }
897 
898 /*
899 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0400
900 * @tc.name: AddAbilityStage
901 * @tc.desc: Verify function AddAbilityStage abilityRecord->GetWant() not empty
902 */
903 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0400, TestSize.Level1)
904 {
905     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0400 start.";
906     std::shared_ptr<AbilityInfo> info = std::make_shared<AbilityInfo>();
907     info->applicationInfo.multiProjects = true;
908     sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
909     std::shared_ptr<AbilityLocalRecord> abilityRecord = std::make_shared<AbilityLocalRecord>(info, token);
910     auto want = std::make_shared<AAFwk::Want>();
911     abilityRecord->SetWant(want);
__anonf594f9500402(const std::shared_ptr<AbilityRuntime::Context> &) 912     auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
913     bool isAsyncCallback = false;
914     ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
915     EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
916     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0400 end.";
917 }
918 
919 /*
920 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0500
921 * @tc.name: AddAbilityStage
922 * @tc.desc: Verify function AddAbilityStage pointer abilityStages not empty
923 */
924 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0500, TestSize.Level1)
925 {
926     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0500 start.";
927     sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
928     std::shared_ptr<AbilityInfo> info = nullptr;
929     std::string moduleName = "entry";
930     std::shared_ptr<AbilityLocalRecord> abilityRecord = std::make_shared<AbilityLocalRecord>(info, token);
931     EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
932     std::shared_ptr<AbilityRuntime::AbilityStage> abilityStages = std::make_shared<AbilityRuntime::AbilityStage>();
933     ohosApplication_->abilityStages_.emplace(moduleName, abilityStages);
__anonf594f9500502(const std::shared_ptr<AbilityRuntime::Context> &) 934     auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
935     bool isAsyncCallback = false;
936     ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
937     EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
938     EXPECT_TRUE(abilityStages != nullptr);
939     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0500 end.";
940 }
941 
942 /*
943 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0600
944 * @tc.name: AddAbilityStage
945 * @tc.desc: Verify function AddAbilityStage pointer token empty
946 */
947 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0600, TestSize.Level1)
948 {
949     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0600 start.";
950     sptr<Notification::MockIRemoteObject> token;
951     std::shared_ptr<AbilityInfo> info = std::make_shared<AbilityInfo>();
952     info->moduleName = "entry";
953     std::shared_ptr<AbilityLocalRecord> abilityRecord = std::make_shared<AbilityLocalRecord>(info, token);
__anonf594f9500602(const std::shared_ptr<AbilityRuntime::Context> &) 954     auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
955     bool isAsyncCallback = false;
956     ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
957     ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
958     EXPECT_TRUE(token == nullptr);
959     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0600 end.";
960 }
961 
962 /*
963 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0700
964 * @tc.name: AddAbilityStage
965 * @tc.desc: Verify function AddAbilityStage pointer token not empty
966 */
967 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0700, TestSize.Level1)
968 {
969     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0700 start.";
970     sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
971     std::shared_ptr<AbilityInfo> info = std::make_shared<AbilityInfo>();
972     std::shared_ptr<AbilityLocalRecord> abilityRecord = std::make_shared<AbilityLocalRecord>(info, token);
973     abilityRecord->token_ = new (std::nothrow) Notification::MockIRemoteObject();
__anonf594f9500702(const std::shared_ptr<AbilityRuntime::Context> &) 974     auto callback = [](const std::shared_ptr<AbilityRuntime::Context> &) {};
975     bool isAsyncCallback = false;
976     ohosApplication_->AddAbilityStage(abilityRecord, callback, isAsyncCallback);
977     EXPECT_TRUE(token != nullptr);
978     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0700 end.";
979 }
980 
981 /*
982 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0800
983 * @tc.name: AddAbilityStage
984 * @tc.desc: Verify function AddAbilityStage pointer abilityRuntimeContext_ empty
985 */
986 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0800, TestSize.Level1)
987 {
988     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0800 start.";
989     HapModuleInfo hapModuleInfo;
__anonf594f9500802() 990     auto callback = []() {};
991     bool isAsyncCallback = false;
992     ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
993     EXPECT_TRUE(ohosApplication_->abilityRuntimeContext_ == nullptr);
994     EXPECT_FALSE(ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback));
995     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0800 end.";
996 }
997 
998 /*
999 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_0900
1000 * @tc.name: AddAbilityStage
1001 * @tc.desc: Verify function AddAbilityStage pointer runtime_ empty
1002 */
1003 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_0900, TestSize.Level1)
1004 {
1005     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0900 start.";
1006     HapModuleInfo hapModuleInfo;
__anonf594f9500902() 1007     auto callback = []() {};
1008     bool isAsyncCallback = false;
1009     ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
1010     ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
1011     EXPECT_TRUE(ohosApplication_->runtime_ == nullptr);
1012     EXPECT_FALSE(ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback));
1013     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_0900 end.";
1014 }
1015 
1016 /*
1017 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_01000
1018 * @tc.name: AddAbilityStage
1019 * @tc.desc: Verify function AddAbilityStage map abilityStages_ not empty
1020 */
1021 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_01000, TestSize.Level1)
1022 {
1023     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01000 start.";
1024     HapModuleInfo hapModuleInfo;
__anonf594f9500a02() 1025     auto callback = []() {};
1026     bool isAsyncCallback = false;
1027     std::string moduleName = "entry";
1028     ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
1029     std::shared_ptr<AbilityRuntime::AbilityStage> abilityStages = std::make_shared<AbilityRuntime::AbilityStage>();
1030     ohosApplication_->abilityStages_.emplace(moduleName, abilityStages);
1031     ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
1032     ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
1033     EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
1034     EXPECT_FALSE(ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback));
1035     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01000 end.";
1036 }
1037 
1038 /*
1039 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_01100
1040 * @tc.name: AddAbilityStage
1041 * @tc.desc: Verify function AddAbilityStage variable moduleInfo empty
1042 */
1043 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_01100, TestSize.Level1)
1044 {
1045     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01100 start.";
1046     HapModuleInfo hapModuleInfo;
__anonf594f9500b02() 1047     auto callback = []() {};
1048     bool isAsyncCallback = false;
1049     ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
1050     ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
1051     EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
1052     ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
1053     ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
1054     auto contextImpl = std::make_shared<AbilityRuntime::ContextImpl>();
1055     auto appInfo = std::make_shared<ApplicationInfo>();
1056     appInfo->multiProjects = true;
1057     contextImpl->SetApplicationInfo(appInfo);
1058     ohosApplication_->abilityRuntimeContext_->AttachContextImpl(contextImpl);
1059     ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
1060     EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
1061     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01100 end.";
1062 }
1063 
1064 /*
1065 * @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_01200
1066 * @tc.name: AddAbilityStage
1067 * @tc.desc: Verify function AddAbilityStage abilityRuntimeContext_->GetApplicationInfo() true
1068 */
1069 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_01200, TestSize.Level1)
1070 {
1071     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01200 start.";
1072     HapModuleInfo hapModuleInfo;
__anonf594f9500c02() 1073     auto callback = []() {};
1074     bool isAsyncCallback = false;
1075     ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
1076     ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
1077     EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
1078     ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
1079     ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
1080     auto contextImpl = std::make_shared<AbilityRuntime::ContextImpl>();
1081     auto appInfo = std::make_shared<ApplicationInfo>();
1082     appInfo->multiProjects = false;
1083     contextImpl->SetApplicationInfo(appInfo);
1084     ohosApplication_->abilityRuntimeContext_->AttachContextImpl(contextImpl);
1085     ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
1086     EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
1087     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_01200 end.";
1088 }
1089 
1090 /*
1091 * @tc.number: AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0100
1092 * @tc.name: CleanAbilityStage
1093 * @tc.desc: Verify function CleanAbilityStage pointer abilityInfo empty
1094 */
1095 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0100, TestSize.Level1)
1096 {
1097     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0100 start.";
1098     std::shared_ptr<AbilityInfo> abilityInfo = nullptr;
1099     sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
1100     ohosApplication_->CleanAbilityStage(token, abilityInfo, false);
1101     EXPECT_TRUE(abilityInfo == nullptr);
1102     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0100 end.";
1103 }
1104 
1105 /*
1106 * @tc.number: AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0200
1107 * @tc.name: CleanAbilityStage
1108 * @tc.desc: Verify function CleanAbilityStage pointer token empty
1109 */
1110 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0200, TestSize.Level1)
1111 {
1112     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0200 start.";
1113     std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
1114     sptr<Notification::MockIRemoteObject> token = nullptr;
1115     ohosApplication_->CleanAbilityStage(token, abilityInfo, false);
1116     EXPECT_TRUE(token == nullptr);
1117     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0200 end.";
1118 }
1119 
1120 /*
1121 * @tc.number: AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0300
1122 * @tc.name: CleanAbilityStage
1123 * @tc.desc: Verify function CleanAbilityStage map abilityRecords_ not empty
1124 */
1125 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0300, TestSize.Level1)
1126 {
1127     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0300 start.";
1128     std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
1129     EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
1130     abilityInfo->moduleName = "entry";
1131     std::shared_ptr<AbilityRuntime::AbilityStage> abilityStage = std::make_shared<AbilityRuntime::AbilityStage>();
1132     sptr<Notification::MockIRemoteObject> token = new (std::nothrow) Notification::MockIRemoteObject();
1133     ohosApplication_->abilityStages_.emplace(abilityInfo->moduleName, abilityStage);
1134     EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
1135     ohosApplication_->CleanAbilityStage(token, abilityInfo, false);
1136     EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
1137     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CleanAbilityStage_0300 end.";
1138 }
1139 
1140 /*
1141 * @tc.number: AppExecFwk_OHOSApplicationTest_GetAppContext_0100
1142 * @tc.name: GetAppContext
1143 * @tc.desc: Verify function GetAppContext pointer token empty
1144 */
1145 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_GetAppContext_0100, TestSize.Level1)
1146 {
1147     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetAppContext_0100 start.";
1148     auto context = ohosApplication_->GetAppContext();
1149     EXPECT_TRUE(context == nullptr);
1150     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetAppContext_0100 end.";
1151 }
1152 
1153 /*
1154 * @tc.number: AppExecFwk_OHOSApplicationTest_GetRuntime_0100
1155 * @tc.name: GetRuntime
1156 * @tc.desc: Verify function GetRuntime pointer token empty
1157 */
1158 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_GetRuntime_0100, TestSize.Level1)
1159 {
1160     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetRuntime_0100 start.";
1161     auto &runtime = ohosApplication_->GetRuntime();
1162     EXPECT_TRUE(runtime == nullptr);
1163     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetRuntime_0100 end.";
1164 }
1165 
1166 /*
1167 * @tc.number: AppExecFwk_OHOSApplicationTest_SetConfiguration_0100
1168 * @tc.name: SetConfiguration
1169 * @tc.desc: Verify function SetConfiguration pointer token empty
1170 */
1171 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetConfiguration_0100, TestSize.Level1)
1172 {
1173     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetConfiguration_0100 start.";
1174     Configuration config;
1175     ohosApplication_->configuration_ = nullptr;
1176     ohosApplication_->SetConfiguration(config);
1177     ohosApplication_->SetConfiguration(config);
1178     EXPECT_TRUE(ohosApplication_->configuration_ != nullptr);
1179     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetConfiguration_0100 end.";
1180 }
1181 
1182 /*
1183 * @tc.number: AppExecFwk_OHOSApplicationTest_ScheduleAcceptWant_0100
1184 * @tc.name: ScheduleAcceptWant
1185 * @tc.desc: Verify function ScheduleAcceptWant pointer abilityStage not empty
1186 */
1187 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_ScheduleAcceptWant_0100, TestSize.Level1)
1188 {
1189     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_ScheduleAcceptWant_0100 start.";
1190     Want want;
1191     std::string flag = "";
1192     std::string moduleName = "entry";
1193     EXPECT_TRUE(ohosApplication_->abilityStages_.empty());
1194     std::shared_ptr<AbilityRuntime::AbilityStage> abilityStage = std::make_shared<AbilityRuntime::AbilityStage>();
1195     ohosApplication_->abilityStages_.emplace(moduleName, abilityStage);
1196     EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
1197     ohosApplication_->ScheduleAcceptWant(want, moduleName, flag);
1198     EXPECT_TRUE(abilityStage != nullptr);
1199     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_ScheduleAcceptWant_0100 end.";
1200 }
1201 
1202 /*
1203 * @tc.number: AppExecFwk_OHOSApplicationTest_GetConfiguration_0100
1204 * @tc.name: GetConfiguration
1205 * @tc.desc: Verify function GetConfiguration pointer configuration_ not empty
1206 */
1207 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_GetConfiguration_0100, TestSize.Level1)
1208 {
1209     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetConfiguration_0100 start.";
1210     Configuration config;
1211     ohosApplication_->configuration_ = nullptr;
1212     ohosApplication_->GetConfiguration();
1213     EXPECT_TRUE(ohosApplication_->configuration_ == nullptr);
1214     ohosApplication_->SetConfiguration(config);
1215     ohosApplication_->GetConfiguration();
1216     EXPECT_TRUE(ohosApplication_->configuration_ != nullptr);
1217     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_GetConfiguration_0100 end.";
1218 }
1219 
1220 /*
1221 * @tc.number: AppExecFwk_OHOSApplicationTest_SetExtensionTypeMap_0100
1222 * @tc.name: SetExtensionTypeMap
1223 * @tc.desc: Verify function SetExtensionTypeMap map extensionTypeMap_ not empty
1224 */
1225 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetExtensionTypeMap_0100, TestSize.Level1)
1226 {
1227     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetExtensionTypeMap_0100 start.";
1228     const std::string name = "entry";
1229     constexpr int32_t id = 1;
1230     std::map<int32_t, std::string> map;
1231     map.emplace(id, name);
1232     ohosApplication_->SetExtensionTypeMap(map);
1233     EXPECT_FALSE(ohosApplication_->extensionTypeMap_.empty());
1234     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetExtensionTypeMap_0100 end.";
1235 }
1236 
1237 /*
1238 * @tc.number: AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0100
1239 * @tc.name: NotifyLoadRepairPatch
1240 * @tc.desc: Verify function NotifyLoadRepairPatch pointer runtime_ empty
1241 */
1242 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0100, TestSize.Level1)
1243 {
1244     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0100 start.";
1245     const std::string hqfFile = "hqfFile";
1246     const std::string hapPat = "hapPat";
1247     EXPECT_TRUE(ohosApplication_->NotifyLoadRepairPatch(hqfFile, hapPat));
1248     EXPECT_TRUE(ohosApplication_->runtime_ == nullptr);
1249     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0100 end.";
1250 }
1251 
1252 /*
1253 * @tc.number: AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0200
1254 * @tc.name: NotifyLoadRepairPatch
1255 * @tc.desc: Verify function NotifyLoadRepairPatch function LoadRepairPatch called
1256 */
1257 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0200, TestSize.Level1)
1258 {
1259     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0200 start.";
1260     const std::string hqfFile = "hqfFile";
1261     const std::string hapPath = "hapPath";
1262     ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
1263     ohosApplication_->NotifyLoadRepairPatch(hqfFile, hapPath);
1264     EXPECT_TRUE(ohosApplication_->runtime_ != nullptr);
1265     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyLoadRepairPatch_0200 end.";
1266 }
1267 
1268 /*
1269 * @tc.number: AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0100
1270 * @tc.name: NotifyHotReloadPage
1271 * @tc.desc: Verify function NotifyHotReloadPage pointer runtime_ empty
1272 */
1273 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0100, TestSize.Level1)
1274 {
1275     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0100 start.";
1276     ohosApplication_->NotifyHotReloadPage();
1277     EXPECT_TRUE(ohosApplication_->runtime_ == nullptr);
1278     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0100 end.";
1279 }
1280 
1281 /*
1282 * @tc.number: AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0200
1283 * @tc.name: NotifyHotReloadPage
1284 * @tc.desc: Verify function NotifyHotReloadPage pointer runtime_ not empty
1285 */
1286 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0200, TestSize.Level1)
1287 {
1288     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0200 start.";
1289     ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
1290     ohosApplication_->NotifyHotReloadPage();
1291     EXPECT_TRUE(ohosApplication_->runtime_ != nullptr);
1292     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyHotReloadPage_0200 end.";
1293 }
1294 
1295 /*
1296 * @tc.number: AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0100
1297 * @tc.name: NotifyUnLoadRepairPatch
1298 * @tc.desc: Verify function NotifyHotReloadPage pointer runtime_ empty
1299 */
1300 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0100, TestSize.Level1)
1301 {
1302     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0100 start.";
1303     std::string hqfFile = "hqfFile";
1304     ohosApplication_->NotifyUnLoadRepairPatch(hqfFile);
1305     EXPECT_TRUE(ohosApplication_->runtime_ == nullptr);
1306     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0100 end.";
1307 }
1308 
1309 /*
1310 * @tc.number: AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0200
1311 * @tc.name: NotifyUnLoadRepairPatch
1312 * @tc.desc: Verify function NotifyHotReloadPage pointer runtime_ not empty
1313 */
1314 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0200, TestSize.Level1)
1315 {
1316     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0200 start.";
1317     ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
1318     std::string hqfFile = "entry";
1319     ohosApplication_->NotifyUnLoadRepairPatch(hqfFile);
1320     EXPECT_TRUE(ohosApplication_->runtime_ != nullptr);
1321     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_NotifyUnLoadRepairPatch_0200 end.";
1322 }
1323 
1324 /*
1325 * @tc.number: AppExecFwk_OHOSApplicationTest_SetAppEnv_0100
1326 * @tc.name: SetAppEnv
1327 * @tc.desc: Verify SetAppEnv function
1328 */
1329 HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetAppEnv_0100, TestSize.Level1)
1330 {
1331     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAppEnv_0100 start.";
1332     AppEnvironment appEnvironment;
1333     appEnvironment.name = "env_key_demo";
1334     appEnvironment.value = "env_value_demo";
1335     std::vector<AppEnvironment> appEnvironments = {appEnvironment};
1336     ohosApplication_->SetAppEnv(appEnvironments);
1337     std::string appEnvVal = getenv(appEnvironment.name.c_str());
1338     EXPECT_EQ(appEnvVal, appEnvironment.value);
1339     GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetAppEnv_0100 end.";
1340 }
1341 }  // namespace AppExecFwk
1342 }  // namespace OHOS
1343