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