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 "application_context.h"
19 #undef private
20 #include "mock_ability_token.h"
21 #include "mock_application_state_change_callback.h"
22 #include "mock_context_impl.h"
23 #include "running_process_info.h"
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace AbilityRuntime {
28 class ApplicationContextTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32 void SetUp() override;
33 void TearDown() override;
34 std::shared_ptr<ApplicationContext> context_ = nullptr;
35 std::shared_ptr<MockContextImpl> mock_ = nullptr;
36 };
37
SetUpTestCase(void)38 void ApplicationContextTest::SetUpTestCase(void)
39 {}
40
TearDownTestCase(void)41 void ApplicationContextTest::TearDownTestCase(void)
42 {}
43
SetUp()44 void ApplicationContextTest::SetUp()
45 {
46 context_ = std::make_shared<ApplicationContext>();
47 mock_ = std::make_shared<MockContextImpl>();
48 }
49
TearDown()50 void ApplicationContextTest::TearDown()
51 {}
52
53 /**
54 * @tc.number: RegisterAbilityLifecycleCallback_0100
55 * @tc.name: RegisterAbilityLifecycleCallback
56 * @tc.desc: Register Ability Lifecycle Callback
57 */
58 HWTEST_F(ApplicationContextTest, RegisterAbilityLifecycleCallback_0100, TestSize.Level1)
59 {
60 GTEST_LOG_(INFO) << "RegisterAbilityLifecycleCallback_0100 start";
61 context_->callbacks_.clear();
62 std::shared_ptr<AbilityLifecycleCallback> abilityLifecycleCallback = nullptr;
63 context_->RegisterAbilityLifecycleCallback(abilityLifecycleCallback);
64 EXPECT_TRUE(context_->IsAbilityLifecycleCallbackEmpty());
65 GTEST_LOG_(INFO) << "RegisterAbilityLifecycleCallback_0100 end";
66 }
67
68 /**
69 * @tc.number: RegisterEnvironmentCallback_0100
70 * @tc.name: RegisterEnvironmentCallback
71 * @tc.desc: Register Environment Callback
72 */
73 HWTEST_F(ApplicationContextTest, RegisterEnvironmentCallback_0100, TestSize.Level1)
74 {
75 GTEST_LOG_(INFO) << "RegisterEnvironmentCallback_0100 start";
76 context_->envCallbacks_.clear();
77 std::shared_ptr<EnvironmentCallback> environmentCallback = nullptr;
78 context_->RegisterEnvironmentCallback(environmentCallback);
79 EXPECT_TRUE(context_->envCallbacks_.empty());
80 GTEST_LOG_(INFO) << "RegisterEnvironmentCallback_0100 end";
81 }
82
83 /**
84 * @tc.number: GetBundleName_0100
85 * @tc.name: GetBundleName
86 * @tc.desc: Get BundleName failed
87 */
88 HWTEST_F(ApplicationContextTest, GetBundleName_0100, TestSize.Level1)
89 {
90 GTEST_LOG_(INFO) << "GetBundleName_0100 start";
91 std::shared_ptr<ContextImpl> contextImpl = nullptr;
92 context_->AttachContextImpl(contextImpl);
93 auto ret = context_->GetBundleName();
94 EXPECT_EQ(ret, "");
95 GTEST_LOG_(INFO) << "GetBundleName_0100 end";
96 }
97
98 /**
99 * @tc.number: GetBundleName_0200
100 * @tc.name: GetBundleName
101 * @tc.desc: Get BundleName sucess
102 */
103 HWTEST_F(ApplicationContextTest, GetBundleName_0200, TestSize.Level1)
104 {
105 GTEST_LOG_(INFO) << "GetBundleName_0200 start";
106 context_->AttachContextImpl(mock_);
107 auto ret = context_->GetBundleName();
108 EXPECT_EQ(ret, "com.test.bundleName");
109 GTEST_LOG_(INFO) << "GetBundleName_0200 end";
110 }
111
112 /**
113 * @tc.number: CreateBundleContext_0100
114 * @tc.name: CreateBundleContext
115 * @tc.desc: Create BundleContext failed
116 */
117 HWTEST_F(ApplicationContextTest, CreateBundleContext_0100, TestSize.Level1)
118 {
119 GTEST_LOG_(INFO) << "CreateBundleContext_0100 start";
120 std::shared_ptr<ContextImpl> contextImpl = nullptr;
121 context_->AttachContextImpl(contextImpl);
122 std::string bundleName = "com.test.bundleName";
123 auto ret = context_->CreateBundleContext(bundleName);
124 EXPECT_EQ(ret, nullptr);
125 GTEST_LOG_(INFO) << "CreateBundleContext_0100 end";
126 }
127
128 /**
129 * @tc.number: CreateBundleContext_0200
130 * @tc.name: CreateBundleContext
131 * @tc.desc: Create BundleContext sucess
132 */
133 HWTEST_F(ApplicationContextTest, CreateBundleContext_0200, TestSize.Level1)
134 {
135 GTEST_LOG_(INFO) << "CreateBundleContext_0200 start";
136 context_->AttachContextImpl(mock_);
137 std::string bundleName = "com.test.bundleName";
138 auto ret = context_->CreateBundleContext(bundleName);
139 EXPECT_NE(ret, nullptr);
140 GTEST_LOG_(INFO) << "CreateBundleContext_0200 end";
141 }
142
143 /**
144 * @tc.number: CreateModuleContext_0100
145 * @tc.name: CreateModuleContext
146 * @tc.desc: Create ModuleContext failed
147 */
148 HWTEST_F(ApplicationContextTest, CreateModuleContext_0100, TestSize.Level1)
149 {
150 GTEST_LOG_(INFO) << "CreateModuleContext_0100 start";
151 std::shared_ptr<ContextImpl> contextImpl = nullptr;
152 context_->AttachContextImpl(contextImpl);
153 std::string moduleName = "moduleName";
154 auto ret = context_->CreateModuleContext(moduleName);
155 EXPECT_EQ(ret, nullptr);
156 GTEST_LOG_(INFO) << "CreateModuleContext_0100 end";
157 }
158
159 /**
160 * @tc.number: CreateModuleContext_0200
161 * @tc.name: CreateModuleContext
162 * @tc.desc: Create ModuleContext sucess
163 */
164 HWTEST_F(ApplicationContextTest, CreateModuleContext_0200, TestSize.Level1)
165 {
166 GTEST_LOG_(INFO) << "CreateModuleContext_0200 start";
167 context_->AttachContextImpl(mock_);
168 std::string moduleName = "moduleName";
169 auto ret = context_->CreateModuleContext(moduleName);
170 EXPECT_NE(ret, nullptr);
171 GTEST_LOG_(INFO) << "CreateModuleContext_0200 end";
172 }
173
174 /**
175 * @tc.number: CreateModuleContext_0300
176 * @tc.name: CreateModuleContext
177 * @tc.desc: Create ModuleContext failed
178 */
179 HWTEST_F(ApplicationContextTest, CreateModuleContext_0300, TestSize.Level1)
180 {
181 GTEST_LOG_(INFO) << "CreateModuleContext_0300 start";
182 std::shared_ptr<ContextImpl> contextImpl = nullptr;
183 context_->AttachContextImpl(contextImpl);
184 std::string moduleName = "moduleName";
185 std::string bundleName = "com.test.bundleName";
186 auto ret = context_->CreateModuleContext(bundleName, moduleName);
187 EXPECT_EQ(ret, nullptr);
188 GTEST_LOG_(INFO) << "CreateModuleContext_0300 end";
189 }
190
191 /**
192 * @tc.number: CreateModuleContext_0400
193 * @tc.name: CreateModuleContext
194 * @tc.desc: Create ModuleContext sucess
195 */
196 HWTEST_F(ApplicationContextTest, CreateModuleContext_0400, TestSize.Level1)
197 {
198 GTEST_LOG_(INFO) << "CreateModuleContext_0400 start";
199 context_->AttachContextImpl(mock_);
200 std::string moduleName = "moduleName";
201 std::string bundleName = "com.test.bundleName";
202 auto ret = context_->CreateModuleContext(bundleName, moduleName);
203 EXPECT_NE(ret, nullptr);
204 GTEST_LOG_(INFO) << "CreateModuleContext_0400 end";
205 }
206
207 /**
208 * @tc.number: GetApplicationInfo_0100
209 * @tc.name: GetApplicationInfo
210 * @tc.desc: Get ApplicationInfo failed
211 */
212 HWTEST_F(ApplicationContextTest, GetApplicationInfo_0100, TestSize.Level1)
213 {
214 GTEST_LOG_(INFO) << "GetApplicationInfo_0100 start";
215 std::shared_ptr<ContextImpl> contextImpl = nullptr;
216 context_->AttachContextImpl(contextImpl);
217 auto ret = context_->GetApplicationInfo();
218 EXPECT_EQ(ret, nullptr);
219 GTEST_LOG_(INFO) << "GetApplicationInfo_0100 end";
220 }
221
222 /**
223 * @tc.number: GetApplicationInfo_0200
224 * @tc.name: GetApplicationInfo
225 * @tc.desc:Get ApplicationInfo sucess
226 */
227 HWTEST_F(ApplicationContextTest, GetApplicationInfo_0200, TestSize.Level1)
228 {
229 GTEST_LOG_(INFO) << "GetApplicationInfo_0200 start";
230 context_->AttachContextImpl(mock_);
231 auto ret = context_->GetApplicationInfo();
232 EXPECT_NE(ret, nullptr);
233 GTEST_LOG_(INFO) << "GetApplicationInfo_0200 end";
234 }
235
236 /**
237 * @tc.number: GetResourceManager_0100
238 * @tc.name: GetResourceManager
239 * @tc.desc: Get ResourceManager failed
240 */
241 HWTEST_F(ApplicationContextTest, GetResourceManager_0100, TestSize.Level1)
242 {
243 GTEST_LOG_(INFO) << "GetResourceManager_0100 start";
244 std::shared_ptr<ContextImpl> contextImpl = nullptr;
245 context_->AttachContextImpl(contextImpl);
246 auto ret = context_->GetResourceManager();
247 EXPECT_EQ(ret, nullptr);
248 GTEST_LOG_(INFO) << "GetResourceManager_0100 end";
249 }
250
251 /**
252 * @tc.number: GetApplicationInfo_0200
253 * @tc.name: GetResourceManager
254 * @tc.desc:Get ResourceManager sucess
255 */
256 HWTEST_F(ApplicationContextTest, GetResourceManager_0200, TestSize.Level1)
257 {
258 GTEST_LOG_(INFO) << "GetResourceManager_0200 start";
259 context_->AttachContextImpl(mock_);
260 auto ret = context_->GetResourceManager();
261 EXPECT_NE(ret, nullptr);
262 GTEST_LOG_(INFO) << "GetResourceManager_0200 end";
263 }
264
265 /**
266 * @tc.number: GetBundleCodePath_0100
267 * @tc.name: GetBundleCodePath
268 * @tc.desc: Get BundleCode Path failed
269 */
270 HWTEST_F(ApplicationContextTest, GetBundleCodePath_0100, TestSize.Level1)
271 {
272 GTEST_LOG_(INFO) << "GetBundleCodePath_0100 start";
273 std::shared_ptr<ContextImpl> contextImpl = nullptr;
274 context_->AttachContextImpl(contextImpl);
275 auto ret = context_->GetBundleCodePath();
276 EXPECT_EQ(ret, "");
277 GTEST_LOG_(INFO) << "GetBundleCodePath_0100 end";
278 }
279
280 /**
281 * @tc.number: GetBundleCodePath_0200
282 * @tc.name: GetBundleCodePath
283 * @tc.desc:Get BundleCode Path sucess
284 */
285 HWTEST_F(ApplicationContextTest, GetBundleCodePath_0200, TestSize.Level1)
286 {
287 GTEST_LOG_(INFO) << "GetBundleCodePath_0200 start";
288 context_->AttachContextImpl(mock_);
289 auto ret = context_->GetBundleCodePath();
290 EXPECT_EQ(ret, "codePath");
291 GTEST_LOG_(INFO) << "GetBundleCodePath_0200 end";
292 }
293
294 /**
295 * @tc.number: GetHapModuleInfo_0100
296 * @tc.name: GetHapModuleInfo
297 * @tc.desc: Get HapModuleInfo failed
298 */
299 HWTEST_F(ApplicationContextTest, GetHapModuleInfo_0100, TestSize.Level1)
300 {
301 GTEST_LOG_(INFO) << "GetHapModuleInfo_0100 start";
302 auto ret = context_->GetHapModuleInfo();
303 EXPECT_EQ(ret, nullptr);
304 GTEST_LOG_(INFO) << "GetHapModuleInfo_0100 end";
305 }
306
307 /**
308 * @tc.number: GetBundleCodeDir_0100
309 * @tc.name: GetBundleCodeDir
310 * @tc.desc: Get Bundle Code Dir failed
311 */
312 HWTEST_F(ApplicationContextTest, GetBundleCodeDir_0100, TestSize.Level1)
313 {
314 GTEST_LOG_(INFO) << "GetBundleCodeDir_0100 start";
315 std::shared_ptr<ContextImpl> contextImpl = nullptr;
316 context_->AttachContextImpl(contextImpl);
317 auto ret = context_->GetBundleCodeDir();
318 EXPECT_EQ(ret, "");
319 GTEST_LOG_(INFO) << "GetBundleCodeDir_0100 end";
320 }
321
322 /**
323 * @tc.number: GetBundleCodeDir_0200
324 * @tc.name: GetBundleCodeDir
325 * @tc.desc:Get Bundle Code Dir sucess
326 */
327 HWTEST_F(ApplicationContextTest, GetBundleCodeDir_0200, TestSize.Level1)
328 {
329 GTEST_LOG_(INFO) << "GetBundleCodeDir_0200 start";
330 context_->AttachContextImpl(mock_);
331 auto ret = context_->GetBundleCodeDir();
332 EXPECT_EQ(ret, "/code");
333 GTEST_LOG_(INFO) << "GetBundleCodeDir_0200 end";
334 }
335
336 /**
337 * @tc.number: GetTempDir_0100
338 * @tc.name: GetTempDir
339 * @tc.desc: Get Temp Dir failed
340 */
341 HWTEST_F(ApplicationContextTest, GetTempDir_0100, TestSize.Level1)
342 {
343 GTEST_LOG_(INFO) << "GetTempDir_0100 start";
344 std::shared_ptr<ContextImpl> contextImpl = nullptr;
345 context_->AttachContextImpl(contextImpl);
346 auto ret = context_->GetTempDir();
347 EXPECT_EQ(ret, "");
348 GTEST_LOG_(INFO) << "GetTempDir_0100 end";
349 }
350
351 /**
352 * @tc.number: GetTempDir_0200
353 * @tc.name: GetTempDir
354 * @tc.desc:Get Temp Dir sucess
355 */
356 HWTEST_F(ApplicationContextTest, GetTempDir_0200, TestSize.Level1)
357 {
358 GTEST_LOG_(INFO) << "GetTempDir_0200 start";
359 context_->AttachContextImpl(mock_);
360 auto ret = context_->GetTempDir();
361 EXPECT_EQ(ret, "/temp");
362 GTEST_LOG_(INFO) << "GetTempDir_0200 end";
363 }
364
365 /**
366 * @tc.number: GetGroupDir_0100
367 * @tc.name: GetGroupDir
368 * @tc.desc: Get Group Dir failed
369 */
370 HWTEST_F(ApplicationContextTest, GetGroupDir_0100, TestSize.Level1)
371 {
372 GTEST_LOG_(INFO) << "GetGroupDir_0100 start";
373 std::shared_ptr<ContextImpl> contextImpl = nullptr;
374 context_->AttachContextImpl(contextImpl);
375 auto ret = context_->GetGroupDir("1");
376 EXPECT_EQ(ret, "");
377 GTEST_LOG_(INFO) << "GetGroupDir_0100 end";
378 }
379
380 /**
381 * @tc.number: GetGroupDir_0200
382 * @tc.name: GetGroupDir
383 * @tc.desc:Get Group Dir sucess
384 */
385 HWTEST_F(ApplicationContextTest, GetGroupDir_0200, TestSize.Level1)
386 {
387 GTEST_LOG_(INFO) << "GetGroupDir_0200 start";
388 context_->AttachContextImpl(mock_);
389 auto ret = context_->GetGroupDir("1");
390 EXPECT_EQ(ret, "/group");
391 GTEST_LOG_(INFO) << "GetGroupDir_0200 end";
392 }
393
394 /**
395 * @tc.number: GetSystemDatabaseDir_0100
396 * @tc.name: GetSystemDatabaseDir
397 * @tc.desc: Get Group Dir failed
398 */
399 HWTEST_F(ApplicationContextTest, GetSystemDatabaseDir_0100, TestSize.Level1)
400 {
401 GTEST_LOG_(INFO) << "GetSystemDatabaseDir_0100 start";
402 std::shared_ptr<ContextImpl> contextImpl = nullptr;
403 context_->AttachContextImpl(contextImpl);
404 std::string databaseDir;
405 auto ret = context_->GetSystemDatabaseDir("1", true, databaseDir);
406 EXPECT_EQ(ret, OHOS::ERR_INVALID_VALUE);
407 GTEST_LOG_(INFO) << "GetSystemDatabaseDir_0100 end";
408 }
409
410 /**
411 * @tc.number: GetSystemDatabaseDir_0200
412 * @tc.name: GetSystemDatabaseDir
413 * @tc.desc:Get Group Dir sucess
414 */
415 HWTEST_F(ApplicationContextTest, GetSystemDatabaseDir_0200, TestSize.Level1)
416 {
417 GTEST_LOG_(INFO) << "GetSystemDatabaseDir_0200 start";
418 context_->AttachContextImpl(mock_);
419 std::string databaseDir;
420 auto ret = context_->GetSystemDatabaseDir("1", true, databaseDir);
421 EXPECT_EQ(ret, 0);
422 GTEST_LOG_(INFO) << "GetSystemDatabaseDir_0200 end";
423 }
424
425 /**
426 * @tc.number: GetSystemPreferencesDir_0100
427 * @tc.name: GetSystemPreferencesDir
428 * @tc.desc: Get Group Dir failed
429 */
430 HWTEST_F(ApplicationContextTest, GetSystemPreferencesDir_0100, TestSize.Level1)
431 {
432 GTEST_LOG_(INFO) << "GetSystemPreferencesDir_0100 start";
433 std::shared_ptr<ContextImpl> contextImpl = nullptr;
434 context_->AttachContextImpl(contextImpl);
435 std::string preferencesDir;
436 auto ret = context_->GetSystemPreferencesDir("1", true, preferencesDir);
437 EXPECT_EQ(ret, OHOS::ERR_INVALID_VALUE);
438 GTEST_LOG_(INFO) << "GetSystemPreferencesDir_0100 end";
439 }
440
441 /**
442 * @tc.number: GetSystemPreferencesDir_0200
443 * @tc.name: GetSystemPreferencesDir
444 * @tc.desc:Get System Preferences Dir sucess
445 */
446 HWTEST_F(ApplicationContextTest, GetSystemPreferencesDir_0200, TestSize.Level1)
447 {
448 GTEST_LOG_(INFO) << "GetSystemDatabaseDir_0200 start";
449 context_->AttachContextImpl(mock_);
450 std::string preferencesDir;
451 auto ret = context_->GetSystemPreferencesDir("1", true, preferencesDir);
452 EXPECT_EQ(ret, 0);
453 GTEST_LOG_(INFO) << "GetSystemPreferencesDir_0200 end";
454 }
455
456 /**
457 * @tc.number: GetFilesDir_0100
458 * @tc.name: GetFilesDir
459 * @tc.desc: Get Files Dir failed
460 */
461 HWTEST_F(ApplicationContextTest, GetFilesDir_0100, TestSize.Level1)
462 {
463 GTEST_LOG_(INFO) << "GetFilesDir_0100 start";
464 std::shared_ptr<ContextImpl> contextImpl = nullptr;
465 context_->AttachContextImpl(contextImpl);
466 auto ret = context_->GetFilesDir();
467 EXPECT_EQ(ret, "");
468 GTEST_LOG_(INFO) << "GetFilesDir_0100 end";
469 }
470
471 /**
472 * @tc.number: GetFilesDir_0200
473 * @tc.name: GetFilesDir
474 * @tc.desc:Get Files Dir sucess
475 */
476 HWTEST_F(ApplicationContextTest, GetFilesDir_0200, TestSize.Level1)
477 {
478 GTEST_LOG_(INFO) << "GetFilesDir_0200 start";
479 context_->AttachContextImpl(mock_);
480 auto ret = context_->GetFilesDir();
481 EXPECT_EQ(ret, "/files");
482 GTEST_LOG_(INFO) << "GetFilesDir_0200 end";
483 }
484
485 /**
486 * @tc.number: IsUpdatingConfigurations_0100
487 * @tc.name: IsUpdatingConfigurations
488 * @tc.desc: Is Updating Configurations failed
489 */
490 HWTEST_F(ApplicationContextTest, IsUpdatingConfigurations_0100, TestSize.Level1)
491 {
492 GTEST_LOG_(INFO) << "IsUpdatingConfigurations_0100 start";
493 std::shared_ptr<ContextImpl> contextImpl = nullptr;
494 context_->AttachContextImpl(contextImpl);
495 auto ret = context_->IsUpdatingConfigurations();
496 EXPECT_EQ(ret, false);
497 GTEST_LOG_(INFO) << "IsUpdatingConfigurations_0100 end";
498 }
499
500 /**
501 * @tc.number: IsUpdatingConfigurations_0200
502 * @tc.name: IsUpdatingConfigurations
503 * @tc.desc:Is Updating Configurations sucess
504 */
505 HWTEST_F(ApplicationContextTest, IsUpdatingConfigurations_0200, TestSize.Level1)
506 {
507 GTEST_LOG_(INFO) << "IsUpdatingConfigurations_0200 start";
508 context_->AttachContextImpl(mock_);
509 auto ret = context_->IsUpdatingConfigurations();
510 EXPECT_EQ(ret, true);
511 GTEST_LOG_(INFO) << "IsUpdatingConfigurations_0200 end";
512 }
513
514 /**
515 * @tc.number: PrintDrawnCompleted_0100
516 * @tc.name: PrintDrawnCompleted
517 * @tc.desc: Print Drawn Completed failed
518 */
519 HWTEST_F(ApplicationContextTest, PrintDrawnCompleted_0100, TestSize.Level1)
520 {
521 GTEST_LOG_(INFO) << "PrintDrawnCompleted_0100 start";
522 std::shared_ptr<ContextImpl> contextImpl = nullptr;
523 context_->AttachContextImpl(contextImpl);
524 auto ret = context_->PrintDrawnCompleted();
525 EXPECT_EQ(ret, false);
526 GTEST_LOG_(INFO) << "PrintDrawnCompleted_0100 end";
527 }
528
529 /**
530 * @tc.number: PrintDrawnCompleted_0200
531 * @tc.name: PrintDrawnCompleted
532 * @tc.desc:Print Drawn Completed sucess
533 */
534 HWTEST_F(ApplicationContextTest, PrintDrawnCompleted_0200, TestSize.Level1)
535 {
536 GTEST_LOG_(INFO) << "PrintDrawnCompleted_0200 start";
537 context_->AttachContextImpl(mock_);
538 auto ret = context_->PrintDrawnCompleted();
539 EXPECT_EQ(ret, true);
540 GTEST_LOG_(INFO) << "PrintDrawnCompleted_0200 end";
541 }
542
543 /**
544 * @tc.number: GetDatabaseDir_0100
545 * @tc.name: GetDatabaseDir
546 * @tc.desc: Get Data base Dir failed
547 */
548 HWTEST_F(ApplicationContextTest, GetDatabaseDir_0100, TestSize.Level1)
549 {
550 GTEST_LOG_(INFO) << "GetDatabaseDir_0100 start";
551 std::shared_ptr<ContextImpl> contextImpl = nullptr;
552 context_->AttachContextImpl(contextImpl);
553 auto ret = context_->GetDatabaseDir();
554 EXPECT_EQ(ret, "");
555 GTEST_LOG_(INFO) << "GetDatabaseDir_0100 end";
556 }
557
558 /**
559 * @tc.number: GetDatabaseDir_0200
560 * @tc.name: GetDatabaseDir
561 * @tc.desc:Get Data base Dir sucess
562 */
563 HWTEST_F(ApplicationContextTest, GetDatabaseDir_0200, TestSize.Level1)
564 {
565 GTEST_LOG_(INFO) << "GetDatabaseDir_0200 start";
566 context_->AttachContextImpl(mock_);
567 auto ret = context_->GetDatabaseDir();
568 EXPECT_EQ(ret, "/data/app/database");
569 GTEST_LOG_(INFO) << "GetDatabaseDir_0200 end";
570 }
571
572 /**
573 * @tc.number: GetPreferencesDir_0100
574 * @tc.name: GetPreferencesDir
575 * @tc.desc: Get Preferences Dir failed
576 */
577 HWTEST_F(ApplicationContextTest, GetPreferencesDir_0100, TestSize.Level1)
578 {
579 GTEST_LOG_(INFO) << "GetPreferencesDir_0100 start";
580 std::shared_ptr<ContextImpl> contextImpl = nullptr;
581 context_->AttachContextImpl(contextImpl);
582 auto ret = context_->GetPreferencesDir();
583 EXPECT_EQ(ret, "");
584 GTEST_LOG_(INFO) << "GetPreferencesDir_0100 end";
585 }
586
587 /**
588 * @tc.number: GetPreferencesDir_0200
589 * @tc.name: GetPreferencesDir
590 * @tc.desc:Get Preferences Dir sucess
591 */
592 HWTEST_F(ApplicationContextTest, GetPreferencesDir_0200, TestSize.Level1)
593 {
594 GTEST_LOG_(INFO) << "GetPreferencesDir_0200 start";
595 context_->AttachContextImpl(mock_);
596 auto ret = context_->GetPreferencesDir();
597 EXPECT_EQ(ret, "/preferences");
598 GTEST_LOG_(INFO) << "GetPreferencesDir_0200 end";
599 }
600
601 /**
602 * @tc.number: GetDistributedFilesDir_0100
603 * @tc.name: GetDistributedFilesDir
604 * @tc.desc: Get Distributed Files Dir failed
605 */
606 HWTEST_F(ApplicationContextTest, GetDistributedFilesDir_0100, TestSize.Level1)
607 {
608 GTEST_LOG_(INFO) << "GetDistributedFilesDir_0100 start";
609 std::shared_ptr<ContextImpl> contextImpl = nullptr;
610 context_->AttachContextImpl(contextImpl);
611 auto ret = context_->GetDistributedFilesDir();
612 EXPECT_EQ(ret, "");
613 GTEST_LOG_(INFO) << "GetDistributedFilesDir_0100 end";
614 }
615
616 /**
617 * @tc.number: GetDistributedFilesDir_0200
618 * @tc.name: GetDistributedFilesDir
619 * @tc.desc:Get Distributed Files Dir sucess
620 */
621 HWTEST_F(ApplicationContextTest, GetDistributedFilesDir_0200, TestSize.Level1)
622 {
623 GTEST_LOG_(INFO) << "GetDistributedFilesDir_0200 start";
624 context_->AttachContextImpl(mock_);
625 auto ret = context_->GetDistributedFilesDir();
626 EXPECT_EQ(ret, "/mnt/hmdfs/device_view/local/data/bundleName");
627 GTEST_LOG_(INFO) << "GetDistributedFilesDir_0200 end";
628 }
629
630 /**
631 * @tc.number: GetToken_0100
632 * @tc.name: GetToken
633 * @tc.desc: Get Token failed
634 */
635 HWTEST_F(ApplicationContextTest, GetToken_0100, TestSize.Level1)
636 {
637 GTEST_LOG_(INFO) << "GetToken_0100 start";
638 std::shared_ptr<ContextImpl> contextImpl = nullptr;
639 context_->AttachContextImpl(contextImpl);
640 auto ret = context_->GetToken();
641 EXPECT_EQ(ret, nullptr);
642 GTEST_LOG_(INFO) << "GetToken_0100 end";
643 }
644
645 /**
646 * @tc.number: GetToken_0200
647 * @tc.name: GetToken
648 * @tc.desc:Get Token sucess
649 */
650 HWTEST_F(ApplicationContextTest, GetToken_0200, TestSize.Level1)
651 {
652 GTEST_LOG_(INFO) << "GetToken_0200 start";
653 std::shared_ptr<ContextImpl> contextImpl = std::make_shared<ContextImpl>();
654 context_->AttachContextImpl(contextImpl);
655 sptr<IRemoteObject> token = new OHOS::AppExecFwk::MockAbilityToken();
656 context_->SetToken(token);
657 auto ret = context_->GetToken();
658 EXPECT_EQ(ret, token);
659 GTEST_LOG_(INFO) << "GetToken_0200 end";
660 }
661
662 /**
663 * @tc.number: GetArea_0100
664 * @tc.name: GetArea
665 * @tc.desc: Get Area failed
666 */
667 HWTEST_F(ApplicationContextTest, GetArea_0100, TestSize.Level1)
668 {
669 GTEST_LOG_(INFO) << "GetArea_0100 start";
670 std::shared_ptr<ContextImpl> contextImpl = nullptr;
671 context_->AttachContextImpl(contextImpl);
672 auto ret = context_->GetArea();
673 EXPECT_EQ(ret, 1);
674 GTEST_LOG_(INFO) << "GetArea_0100 end";
675 }
676
677 /**
678 * @tc.number: GetArea_0200
679 * @tc.name: GetArea
680 * @tc.desc:Get Area sucess
681 */
682 HWTEST_F(ApplicationContextTest, GetArea_0200, TestSize.Level1)
683 {
684 GTEST_LOG_(INFO) << "GetArea_0200 start";
685 std::shared_ptr<ContextImpl> contextImpl = std::make_shared<ContextImpl>();
686 context_->AttachContextImpl(contextImpl);
687 int32_t mode = 1;
688 context_->SwitchArea(mode);
689 auto ret = context_->GetArea();
690 EXPECT_EQ(ret, mode);
691 GTEST_LOG_(INFO) << "GetArea_0200 end";
692 }
693
694 /**
695 * @tc.number: GetConfiguration_0100
696 * @tc.name: GetConfiguration
697 * @tc.desc: Get Configuration failed
698 */
699 HWTEST_F(ApplicationContextTest, GetConfiguration_0100, TestSize.Level1)
700 {
701 GTEST_LOG_(INFO) << "GetConfiguration_0100 start";
702 std::shared_ptr<ContextImpl> contextImpl = nullptr;
703 context_->AttachContextImpl(contextImpl);
704 auto ret = context_->GetConfiguration();
705 EXPECT_EQ(ret, nullptr);
706 GTEST_LOG_(INFO) << "GetConfiguration_0100 end";
707 }
708
709 /**
710 * @tc.number: GetConfiguration_0200
711 * @tc.name: GetConfiguration
712 * @tc.desc:Get Configuration sucess
713 */
714 HWTEST_F(ApplicationContextTest, GetConfiguration_0200, TestSize.Level1)
715 {
716 GTEST_LOG_(INFO) << "GetConfiguration_0200 start";
717 context_->AttachContextImpl(mock_);
718 auto ret = context_->GetConfiguration();
719 EXPECT_NE(ret, nullptr);
720 GTEST_LOG_(INFO) << "GetConfiguration_0200 end";
721 }
722
723 /**
724 * @tc.number: GetBaseDir_0100
725 * @tc.name: GetBaseDir
726 * @tc.desc:Get Base Dir sucess
727 */
728 HWTEST_F(ApplicationContextTest, GetBaseDir_0100, TestSize.Level1)
729 {
730 GTEST_LOG_(INFO) << "GetBaseDir_0100 start";
731 context_->AttachContextImpl(mock_);
732 auto ret = context_->GetBaseDir();
733 EXPECT_EQ(ret, "/data/app/base");
734 GTEST_LOG_(INFO) << "GetBaseDir_0100 end";
735 }
736
737 /**
738 * @tc.number: GetDeviceType_0100
739 * @tc.name: GetDeviceType
740 * @tc.desc: Get DeviceType failed
741 */
742 HWTEST_F(ApplicationContextTest, GetDeviceType_0100, TestSize.Level1)
743 {
744 GTEST_LOG_(INFO) << "GetDeviceType_0100 start";
745 std::shared_ptr<ContextImpl> contextImpl = nullptr;
746 context_->AttachContextImpl(contextImpl);
747 auto ret = context_->GetDeviceType();
748 EXPECT_EQ(ret, Global::Resource::DeviceType::DEVICE_PHONE);
749 GTEST_LOG_(INFO) << "GetDeviceType_0100 end";
750 }
751
752 /**
753 * @tc.number: GetDeviceType_0200
754 * @tc.name: GetDeviceType
755 * @tc.desc:Get DeviceType sucess
756 */
757 HWTEST_F(ApplicationContextTest, GetDeviceType_0200, TestSize.Level1)
758 {
759 GTEST_LOG_(INFO) << "GetDeviceType_0200 start";
760 context_->AttachContextImpl(mock_);
761 auto ret = context_->GetDeviceType();
762 EXPECT_EQ(ret, Global::Resource::DeviceType::DEVICE_NOT_SET);
763 GTEST_LOG_(INFO) << "GetDeviceType_0200 end";
764 }
765
766 /**
767 * @tc.number: UnregisterEnvironmentCallback_0100
768 * @tc.name: UnregisterEnvironmentCallback
769 * @tc.desc: unregister Environment Callback
770 */
771 HWTEST_F(ApplicationContextTest, UnregisterEnvironmentCallback_0100, TestSize.Level1)
772 {
773 GTEST_LOG_(INFO) << "UnregisterEnvironmentCallback_0100 start";
774 context_->envCallbacks_.clear();
775 std::shared_ptr<EnvironmentCallback> environmentCallback = nullptr;
776 context_->UnregisterEnvironmentCallback(environmentCallback);
777 EXPECT_TRUE(context_->envCallbacks_.empty());
778 GTEST_LOG_(INFO) << "UnregisterEnvironmentCallback_0100 end";
779 }
780
781 /**
782 * @tc.number: DispatchOnAbilityCreate_0100
783 * @tc.name: DispatchOnAbilityCreate
784 * @tc.desc: DispatchOnAbilityCreate
785 */
786 HWTEST_F(ApplicationContextTest, DispatchOnAbilityCreate_0100, TestSize.Level1)
787 {
788 GTEST_LOG_(INFO) << "DispatchOnAbilityCreate_0100 start";
789 EXPECT_NE(context_, nullptr);
790 std::shared_ptr<NativeReference> ability = nullptr;
791 context_->DispatchOnAbilityCreate(ability);
792 GTEST_LOG_(INFO) << "DispatchOnAbilityCreate_0100 end";
793 }
794
795 /**
796 * @tc.number: DispatchOnWindowStageCreate_0100
797 * @tc.name: DispatchOnWindowStageCreate
798 * @tc.desc: DispatchOnWindowStageCreate
799 */
800 HWTEST_F(ApplicationContextTest, DispatchOnWindowStageCreate_0100, TestSize.Level1)
801 {
802 GTEST_LOG_(INFO) << "DispatchOnWindowStageCreate_0100 start";
803 EXPECT_NE(context_, nullptr);
804 std::shared_ptr<NativeReference> ability = nullptr;
805 std::shared_ptr<NativeReference> windowStage = nullptr;
806 context_->DispatchOnWindowStageCreate(ability, windowStage);
807 GTEST_LOG_(INFO) << "DispatchOnWindowStageCreate_0100 end";
808 }
809
810 /**
811 * @tc.number: DispatchOnWindowStageDestroy_0100
812 * @tc.name: DispatchOnWindowStageDestroy
813 * @tc.desc: DispatchOnWindowStageDestroy
814 */
815 HWTEST_F(ApplicationContextTest, DispatchOnWindowStageDestroy_0100, TestSize.Level1)
816 {
817 GTEST_LOG_(INFO) << "DispatchOnWindowStageDestroy_0100 start";
818 EXPECT_NE(context_, nullptr);
819 std::shared_ptr<NativeReference> ability = nullptr;
820 std::shared_ptr<NativeReference> windowStage = nullptr;
821 context_->DispatchOnWindowStageDestroy(ability, windowStage);
822 GTEST_LOG_(INFO) << "DispatchOnWindowStageDestroy_0100 end";
823 }
824
825 /**
826 * @tc.number: DispatchWindowStageFocus_0100
827 * @tc.name: DispatchWindowStageFocus
828 * @tc.desc: DispatchWindowStageFocus
829 */
830 HWTEST_F(ApplicationContextTest, DispatchWindowStageFocus_0100, TestSize.Level1)
831 {
832 GTEST_LOG_(INFO) << "DispatchWindowStageFocus_0100 start";
833 EXPECT_NE(context_, nullptr);
834 std::shared_ptr<NativeReference> ability = nullptr;
835 std::shared_ptr<NativeReference> windowStage = nullptr;
836 context_->DispatchWindowStageFocus(ability, windowStage);
837 GTEST_LOG_(INFO) << "DispatchWindowStageFocus_0100 end";
838 }
839
840 /**
841 * @tc.number: DispatchWindowStageUnfocus_0100
842 * @tc.name: DispatchWindowStageUnfocus
843 * @tc.desc: DispatchWindowStageUnfocus
844 */
845 HWTEST_F(ApplicationContextTest, DispatchWindowStageUnfocus_0100, TestSize.Level1)
846 {
847 GTEST_LOG_(INFO) << "DispatchWindowStageUnfocus_0100 start";
848 EXPECT_NE(context_, nullptr);
849 std::shared_ptr<NativeReference> ability = nullptr;
850 std::shared_ptr<NativeReference> windowStage = nullptr;
851 context_->DispatchWindowStageUnfocus(ability, windowStage);
852 GTEST_LOG_(INFO) << "DispatchWindowStageUnfocus_0100 end";
853 }
854
855 /**
856 * @tc.number: DispatchOnAbilityDestroy_0100
857 * @tc.name: DispatchOnAbilityDestroy
858 * @tc.desc: DispatchOnAbilityDestroy
859 */
860 HWTEST_F(ApplicationContextTest, DispatchOnAbilityDestroy_0100, TestSize.Level1)
861 {
862 GTEST_LOG_(INFO) << "DispatchOnAbilityDestroy_0100 start";
863 EXPECT_NE(context_, nullptr);
864 std::shared_ptr<NativeReference> ability = nullptr;
865 context_->DispatchOnAbilityDestroy(ability);
866 GTEST_LOG_(INFO) << "DispatchOnAbilityDestroy_0100 end";
867 }
868
869 /**
870 * @tc.number: DispatchOnAbilityForeground_0100
871 * @tc.name: DispatchOnAbilityForeground
872 * @tc.desc: DispatchOnAbilityForeground
873 */
874 HWTEST_F(ApplicationContextTest, DispatchOnAbilityForeground_0100, TestSize.Level1)
875 {
876 GTEST_LOG_(INFO) << "DispatchOnAbilityForeground_0100 start";
877 EXPECT_NE(context_, nullptr);
878 std::shared_ptr<NativeReference> ability = nullptr;
879 context_->DispatchOnAbilityForeground(ability);
880 GTEST_LOG_(INFO) << "DispatchOnAbilityForeground_0100 end";
881 }
882
883 /**
884 * @tc.number: DispatchOnAbilityBackground_0100
885 * @tc.name: DispatchOnAbilityBackground
886 * @tc.desc: DispatchOnAbilityBackground
887 */
888 HWTEST_F(ApplicationContextTest, DispatchOnAbilityBackground_0100, TestSize.Level1)
889 {
890 GTEST_LOG_(INFO) << "DispatchOnAbilityBackground_0100 start";
891 EXPECT_NE(context_, nullptr);
892 std::shared_ptr<NativeReference> ability = nullptr;
893 context_->DispatchOnAbilityBackground(ability);
894 GTEST_LOG_(INFO) << "DispatchOnAbilityBackground_0100 end";
895 }
896
897 /**
898 * @tc.number: DispatchOnAbilityContinue_0100
899 * @tc.name: DispatchOnAbilityContinue
900 * @tc.desc: DispatchOnAbilityContinue
901 */
902 HWTEST_F(ApplicationContextTest, DispatchOnAbilityContinue_0100, TestSize.Level1)
903 {
904 GTEST_LOG_(INFO) << "DispatchOnAbilityContinue_0100 start";
905 EXPECT_NE(context_, nullptr);
906 std::shared_ptr<NativeReference> ability = nullptr;
907 context_->DispatchOnAbilityContinue(ability);
908 GTEST_LOG_(INFO) << "DispatchOnAbilityContinue_0100 end";
909 }
910
911 /**
912 * @tc.number: SetApplicationInfo_0100
913 * @tc.name: SetApplicationInfo
914 * @tc.desc: SetApplicationInfo
915 */
916 HWTEST_F(ApplicationContextTest, SetApplicationInfo_0100, TestSize.Level1)
917 {
918 GTEST_LOG_(INFO) << "SetApplicationInfo_0100 start";
919 EXPECT_NE(context_, nullptr);
920 std::shared_ptr<AppExecFwk::ApplicationInfo> info = nullptr;
921 context_->SetApplicationInfo(info);
922 GTEST_LOG_(INFO) << "SetApplicationInfo_0100 end";
923 }
924
925 /**
926 * @tc.number: KillProcessBySelf_0100
927 * @tc.name: KillProcessBySelf
928 * @tc.desc: KillProcessBySelf
929 */
930 HWTEST_F(ApplicationContextTest, KillProcessBySelf_0100, TestSize.Level1)
931 {
932 GTEST_LOG_(INFO) << "KillProcessBySelf_0100 start";
933 EXPECT_NE(context_, nullptr);
934 context_->KillProcessBySelf();
935 GTEST_LOG_(INFO) << "KillProcessBySelf_0100 end";
936 }
937
938 /**
939 * @tc.number: GetProcessRunningInformation_0100
940 * @tc.name: GetProcessRunningInformation
941 * @tc.desc: GetProcessRunningInformation
942 */
943 HWTEST_F(ApplicationContextTest, GetProcessRunningInformation_0100, TestSize.Level1)
944 {
945 GTEST_LOG_(INFO) << "GetProcessRunningInformation_0100 start";
946 std::shared_ptr<ContextImpl> contextImpl = nullptr;
947 context_->AttachContextImpl(contextImpl);
948 AppExecFwk::RunningProcessInfo info;
949 auto ret = context_->GetProcessRunningInformation(info);
950 EXPECT_EQ(ret, -1);
951 GTEST_LOG_(INFO) << "GetProcessRunningInformation_0100 end";
952 }
953
954 /**
955 * @tc.number: GetCacheDir_0100
956 * @tc.name: GetCacheDir
957 * @tc.desc: Get Bundle Code Dir failed
958 */
959 HWTEST_F(ApplicationContextTest, GetCacheDir_0100, TestSize.Level1)
960 {
961 GTEST_LOG_(INFO) << "GetCacheDir_0100 start";
962 std::shared_ptr<ContextImpl> contextImpl = nullptr;
963 context_->AttachContextImpl(contextImpl);
964 auto ret = context_->GetCacheDir();
965 EXPECT_EQ(ret, "");
966 GTEST_LOG_(INFO) << "GetCacheDir_0100 end";
967 }
968
969 /**
970 * @tc.number: RegisterApplicationStateChangeCallback_0100
971 * @tc.name: RegisterApplicationStateChangeCallback
972 * @tc.desc: Pass in nullptr parameters, and the callback saved in the ApplicationContext is also nullptr
973 */
974 HWTEST_F(ApplicationContextTest, RegisterApplicationStateChangeCallback_0100, TestSize.Level1)
975 {
976 GTEST_LOG_(INFO) << "RegisterApplicationStateChangeCallback_0100 start";
977 context_->applicationStateCallback_.reset();
978 std::shared_ptr<MockApplicationStateChangeCallback> applicationStateCallback = nullptr;
979 context_->RegisterApplicationStateChangeCallback(applicationStateCallback);
980 auto callback = context_->applicationStateCallback_.lock();
981 EXPECT_EQ(callback, nullptr);
982 GTEST_LOG_(INFO) << "RegisterApplicationStateChangeCallback_0100 end";
983 }
984
985 /**
986 * @tc.number: NotifyApplicationForeground_0100
987 * @tc.name: NotifyApplicationForeground and RegisterApplicationStateChangeCallback
988 * @tc.desc: Pass 1 register a valid callback, NotifyApplicationForeground is called
989 * 2 the callback saved in the ApplicationContext is valid
990 */
991 HWTEST_F(ApplicationContextTest, NotifyApplicationForeground_0100, TestSize.Level1)
992 {
993 GTEST_LOG_(INFO) << "NotifyApplicationForeground_0100 start";
994 auto callback = context_->applicationStateCallback_.lock();
995 EXPECT_EQ(callback, nullptr);
996
997 auto applicationStateCallback = std::make_shared<MockApplicationStateChangeCallback>();
998 context_->RegisterApplicationStateChangeCallback(applicationStateCallback);
999 EXPECT_CALL(*applicationStateCallback, NotifyApplicationForeground()).Times(1);
1000 context_->NotifyApplicationForeground();
1001 callback = context_->applicationStateCallback_.lock();
1002 EXPECT_NE(callback, nullptr);
1003 GTEST_LOG_(INFO) << "NotifyApplicationForeground_0100 end";
1004 }
1005
1006 /**
1007 * @tc.number: NotifyApplicationBackground_0100
1008 * @tc.name: NotifyApplicationBackground and RegisterApplicationStateChangeCallback
1009 * @tc.desc: Pass 1 register a valid callback, NotifyApplicationBackground is called
1010 * 2 the callback saved in the ApplicationContext is valid
1011 */
1012 HWTEST_F(ApplicationContextTest, NotifyApplicationBackground_0100, TestSize.Level1)
1013 {
1014 GTEST_LOG_(INFO) << "NotifyApplicationBackground_0100 start";
1015 auto callback = context_->applicationStateCallback_.lock();
1016 EXPECT_EQ(callback, nullptr);
1017
1018 auto applicationStateCallback = std::make_shared<MockApplicationStateChangeCallback>();
1019 context_->RegisterApplicationStateChangeCallback(applicationStateCallback);
1020 EXPECT_CALL(*applicationStateCallback, NotifyApplicationBackground()).Times(1);
1021 context_->NotifyApplicationBackground();
1022 callback = context_->applicationStateCallback_.lock();
1023 EXPECT_NE(callback, nullptr);
1024 GTEST_LOG_(INFO) << "NotifyApplicationBackground_0100 end";
1025 }
1026 } // namespace AbilityRuntime
1027 } // namespace OHOS