1 /*
2 * Copyright (c) 2021-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
18 #define private public
19 #include "app_state_observer_manager.h"
20 #undef private
21 #include "application_state_observer_stub.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace AppExecFwk {
28 namespace {
29 const int BUNDLE_NAME_LIST_MAX_SIZE = 128;
30 }
31 class MockApplicationStateObserver : public IApplicationStateObserver {
32 public:
33 MockApplicationStateObserver() = default;
34 virtual ~MockApplicationStateObserver() = default;
OnForegroundApplicationChanged(const AppStateData & appStateData)35 void OnForegroundApplicationChanged(const AppStateData &appStateData) override
36 {}
OnAbilityStateChanged(const AbilityStateData & abilityStateData)37 void OnAbilityStateChanged(const AbilityStateData &abilityStateData) override
38 {}
OnExtensionStateChanged(const AbilityStateData & abilityStateData)39 void OnExtensionStateChanged(const AbilityStateData &abilityStateData) override
40 {}
OnProcessCreated(const ProcessData & processData)41 void OnProcessCreated(const ProcessData &processData) override
42 {}
OnProcessStateChanged(const ProcessData & processData)43 void OnProcessStateChanged(const ProcessData &processData) override
44 {}
OnProcessDied(const ProcessData & processData)45 void OnProcessDied(const ProcessData &processData) override
46 {}
OnApplicationStateChanged(const AppStateData & appStateData)47 void OnApplicationStateChanged(const AppStateData &appStateData) override
48 {}
OnAppStateChanged(const AppStateData & appStateData)49 void OnAppStateChanged(const AppStateData &appStateData) override
50 {}
OnAppStarted(const AppStateData & appStateData)51 void OnAppStarted(const AppStateData &appStateData) override
52 {}
OnAppStopped(const AppStateData & appStateData)53 void OnAppStopped(const AppStateData &appStateData) override
54 {}
AsObject()55 sptr<IRemoteObject> AsObject() override
56 {
57 return {};
58 }
59 };
60 class AppSpawnSocketTest : public testing::Test {
61 public:
62 static void SetUpTestCase();
63 static void TearDownTestCase();
64 void SetUp();
65 void TearDown();
66 std::shared_ptr<AppRunningRecord> MockAppRecord();
67 sptr<IApplicationStateObserver> observer_ {nullptr};
68 };
69
SetUpTestCase()70 void AppSpawnSocketTest::SetUpTestCase()
71 {}
72
TearDownTestCase()73 void AppSpawnSocketTest::TearDownTestCase()
74 {}
75
SetUp()76 void AppSpawnSocketTest::SetUp()
77 {
78 sptr<IApplicationStateObserver> observer_ = new MockApplicationStateObserver();
79 }
80
TearDown()81 void AppSpawnSocketTest::TearDown()
82 {}
83
MockAppRecord()84 std::shared_ptr<AppRunningRecord> AppSpawnSocketTest::MockAppRecord()
85 {
86 ApplicationInfo appInfo;
87 appInfo.accessTokenId = 1;
88 std::shared_ptr<ApplicationInfo> info = std::make_shared<ApplicationInfo>(appInfo);
89 info->accessTokenId = 1;
90 std::shared_ptr<AppRunningRecord> appRecord = std::make_shared<AppRunningRecord>(info, 0, "process");
91 std::shared_ptr<PriorityObject> priorityObject = std::make_shared<PriorityObject>();
92 priorityObject->SetPid(1);
93 appRecord->priorityObject_ = priorityObject;
94 appRecord->SetUid(1);
95 appRecord->SetState(ApplicationState::APP_STATE_CREATE);
96 appRecord->SetContinuousTaskAppState(false);
97 appRecord->SetKeepAliveAppState(false, false);
98 appRecord->SetRequestProcCode(1);
99 appRecord->isFocused_ = false;
100 return appRecord;
101 }
102
103 /*
104 * Feature: AppStateObserverManager
105 * Function: RegisterApplicationStateObserver
106 * SubFunction: NA
107 * FunctionPoints: AppStateObserverManager RegisterApplicationStateObserver
108 * EnvConditions: NA
109 * CaseDescription: Verify RegisterApplicationStateObserver
110 */
111 HWTEST_F(AppSpawnSocketTest, RegisterApplicationStateObserver_001, TestSize.Level0)
112 {
113 auto manager = std::make_shared<AppStateObserverManager>();
114 vector<std::string> bundleNameList;
115 int32_t res = manager->RegisterApplicationStateObserver(nullptr, bundleNameList);
116 EXPECT_EQ(res, ERR_PERMISSION_DENIED);
117 }
118
119 /*
120 * Feature: AppStateObserverManager
121 * Function: RegisterApplicationStateObserver
122 * SubFunction: NA
123 * FunctionPoints: AppStateObserverManager RegisterApplicationStateObserver
124 * EnvConditions: NA
125 * CaseDescription: Verify RegisterApplicationStateObserver
126 */
127 HWTEST_F(AppSpawnSocketTest, RegisterApplicationStateObserver_002, TestSize.Level0)
128 {
129 auto manager = std::make_shared<AppStateObserverManager>();
130 vector<std::string> bundleNameList;
131 while (bundleNameList.size() <= BUNDLE_NAME_LIST_MAX_SIZE) {
132 bundleNameList.push_back("a");
133 }
134 int32_t res = manager->RegisterApplicationStateObserver(nullptr, bundleNameList);
135 EXPECT_EQ(res, ERR_INVALID_VALUE);
136 }
137
138 /*
139 * Feature: AppStateObserverManager
140 * Function: UnregisterApplicationStateObserver
141 * SubFunction: NA
142 * FunctionPoints: AppStateObserverManager UnregisterApplicationStateObserver
143 * EnvConditions: NA
144 * CaseDescription: Verify UnregisterApplicationStateObserver
145 */
146 HWTEST_F(AppSpawnSocketTest, UnregisterApplicationStateObserver_001, TestSize.Level0)
147 {
148 auto manager = std::make_shared<AppStateObserverManager>();
149 int32_t res = manager->UnregisterApplicationStateObserver(nullptr);
150 EXPECT_EQ(res, ERR_PERMISSION_DENIED);
151 }
152
153 /*
154 * Feature: AppStateObserverManager
155 * Function: OnAppStarted
156 * SubFunction: NA
157 * FunctionPoints: AppStateObserverManager OnAppStarted
158 * EnvConditions: NA
159 * CaseDescription: Verify OnAppStarted
160 */
161 HWTEST_F(AppSpawnSocketTest, OnAppStarted_001, TestSize.Level0)
162 {
163 auto manager = std::make_shared<AppStateObserverManager>();
164 ASSERT_NE(manager, nullptr);
165 std::shared_ptr<AppRunningRecord> appRecord;
166 manager->OnAppStarted(appRecord);
167 manager->Init();
168 manager->OnAppStarted(appRecord);
169 }
170
171 /*
172 * Feature: AppStateObserverManager
173 * Function: OnAppStopped
174 * SubFunction: NA
175 * FunctionPoints: AppStateObserverManager OnAppStopped
176 * EnvConditions: NA
177 * CaseDescription: Verify OnAppStopped
178 */
179 HWTEST_F(AppSpawnSocketTest, OnAppStopped_001, TestSize.Level0)
180 {
181 auto manager = std::make_shared<AppStateObserverManager>();
182 ASSERT_NE(manager, nullptr);
183 std::shared_ptr<AppRunningRecord> appRecord;
184 manager->OnAppStopped(appRecord);
185 manager->Init();
186 manager->OnAppStopped(appRecord);
187 }
188
189 /*
190 * Feature: AppStateObserverManager
191 * Function: OnAppStateChanged
192 * SubFunction: NA
193 * FunctionPoints: AppStateObserverManager OnAppStateChanged
194 * EnvConditions: NA
195 * CaseDescription: Verify OnAppStateChanged
196 */
197 HWTEST_F(AppSpawnSocketTest, OnAppStateChanged_001, TestSize.Level0)
198 {
199 auto manager = std::make_shared<AppStateObserverManager>();
200 ASSERT_NE(manager, nullptr);
201 std::shared_ptr<AppRunningRecord> appRecord;
202 ApplicationState state = ApplicationState::APP_STATE_CREATE;
203 bool needNotifyApp = false;
204 manager->OnAppStateChanged(appRecord, state, needNotifyApp);
205 }
206
207 /*
208 * Feature: AppStateObserverManager
209 * Function: OnAppStateChanged
210 * SubFunction: NA
211 * FunctionPoints: AppStateObserverManager OnAppStateChanged
212 * EnvConditions: NA
213 * CaseDescription: Verify OnAppStateChanged
214 */
215 HWTEST_F(AppSpawnSocketTest, OnAppStateChanged_002, TestSize.Level0)
216 {
217 auto manager = std::make_shared<AppStateObserverManager>();
218 ASSERT_NE(manager, nullptr);
219 std::shared_ptr<AppRunningRecord> appRecord;
220 ApplicationState state = ApplicationState::APP_STATE_CREATE;
221 bool needNotifyApp = false;
222 manager->Init();
223 manager->OnAppStateChanged(appRecord, state, needNotifyApp);
224 }
225
226 /*
227 * Feature: AppStateObserverManager
228 * Function: OnProcessDied
229 * SubFunction: NA
230 * FunctionPoints: AppStateObserverManager OnProcessDied
231 * EnvConditions: NA
232 * CaseDescription: Verify OnProcessDied
233 */
234 HWTEST_F(AppSpawnSocketTest, OnProcessDied_001, TestSize.Level0)
235 {
236 auto manager = std::make_shared<AppStateObserverManager>();
237 ASSERT_NE(manager, nullptr);
238 std::shared_ptr<AppRunningRecord> appRecord;
239 manager->OnProcessDied(appRecord);
240 manager->Init();
241 manager->OnProcessDied(appRecord);
242 }
243
244 /*
245 * Feature: AppStateObserverManager
246 * Function: OnRenderProcessDied
247 * SubFunction: NA
248 * FunctionPoints: AppStateObserverManager OnRenderProcessDied
249 * EnvConditions: NA
250 * CaseDescription: Verify OnRenderProcessDied
251 */
252 HWTEST_F(AppSpawnSocketTest, OnRenderProcessDied_001, TestSize.Level0)
253 {
254 auto manager = std::make_shared<AppStateObserverManager>();
255 ASSERT_NE(manager, nullptr);
256 std::shared_ptr<RenderRecord> renderRecord;
257 manager->OnRenderProcessDied(renderRecord);
258 manager->Init();
259 manager->OnRenderProcessDied(renderRecord);
260 }
261
262 /*
263 * Feature: AppStateObserverManager
264 * Function: OnProcessStateChanged
265 * SubFunction: NA
266 * FunctionPoints: AppStateObserverManager OnProcessStateChanged
267 * EnvConditions: NA
268 * CaseDescription: Verify OnProcessStateChanged
269 */
270 HWTEST_F(AppSpawnSocketTest, OnProcessStateChanged_001, TestSize.Level0)
271 {
272 auto manager = std::make_shared<AppStateObserverManager>();
273 ASSERT_NE(manager, nullptr);
274 std::shared_ptr<AppRunningRecord> appRecord;
275 manager->OnProcessStateChanged(appRecord);
276 manager->Init();
277 manager->OnProcessStateChanged(appRecord);
278 }
279
280 /*
281 * Feature: AppStateObserverManager
282 * Function: OnProcessCreated
283 * SubFunction: NA
284 * FunctionPoints: AppStateObserverManager OnProcessCreated
285 * EnvConditions: NA
286 * CaseDescription: Verify OnProcessCreated
287 */
288 HWTEST_F(AppSpawnSocketTest, OnProcessCreated_001, TestSize.Level0)
289 {
290 auto manager = std::make_shared<AppStateObserverManager>();
291 ASSERT_NE(manager, nullptr);
292 std::shared_ptr<AppRunningRecord> appRecord;
293 manager->OnProcessCreated(appRecord);
294 manager->Init();
295 manager->OnProcessCreated(appRecord);
296 }
297
298 /*
299 * Feature: AppStateObserverManager
300 * Function: OnRenderProcessCreated
301 * SubFunction: NA
302 * FunctionPoints: AppStateObserverManager OnRenderProcessCreated
303 * EnvConditions: NA
304 * CaseDescription: Verify OnRenderProcessCreated
305 */
306 HWTEST_F(AppSpawnSocketTest, OnRenderProcessCreated_001, TestSize.Level0)
307 {
308 auto manager = std::make_shared<AppStateObserverManager>();
309 ASSERT_NE(manager, nullptr);
310 std::shared_ptr<RenderRecord> renderRecord;
311 manager->OnRenderProcessCreated(renderRecord);
312 manager->Init();
313 manager->OnRenderProcessCreated(renderRecord);
314 }
315
316 /*
317 * Feature: AppStateObserverManager
318 * Function: StateChangedNotifyObserver
319 * SubFunction: NA
320 * FunctionPoints: AppStateObserverManager StateChangedNotifyObserver
321 * EnvConditions: NA
322 * CaseDescription: Verify StateChangedNotifyObserver
323 */
324 HWTEST_F(AppSpawnSocketTest, StateChangedNotifyObserver_001, TestSize.Level0)
325 {
326 auto manager = std::make_shared<AppStateObserverManager>();
327 ASSERT_NE(manager, nullptr);
328 AbilityStateData abilityStateData;
329 bool isAbility = false;
330 manager->StateChangedNotifyObserver(abilityStateData, isAbility);
331 manager->Init();
332 manager->StateChangedNotifyObserver(abilityStateData, isAbility);
333 }
334
335 /*
336 * Feature: AppStateObserverManager
337 * Function: HandleOnAppStarted
338 * SubFunction: NA
339 * FunctionPoints: AppStateObserverManager HandleOnAppStarted
340 * EnvConditions: NA
341 * CaseDescription: Verify HandleOnAppStarted
342 */
343 HWTEST_F(AppSpawnSocketTest, HandleOnAppStarted_001, TestSize.Level0)
344 {
345 auto manager = std::make_shared<AppStateObserverManager>();
346 ASSERT_NE(manager, nullptr);
347 manager->HandleOnAppStarted(nullptr);
348 std::vector<std::string> bundleNameList;
349 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
350 std::string bundleName = "com.ohos.unittest";
351 appRecord->mainBundleName_ = bundleName;
352 bundleNameList.push_back(bundleName);
353 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
354 manager->HandleOnAppStarted(appRecord);
355 }
356
357 /*
358 * Feature: AppStateObserverManager
359 * Function: HandleOnAppStarted
360 * SubFunction: NA
361 * FunctionPoints: AppStateObserverManager HandleOnAppStarted
362 * EnvConditions: NA
363 * CaseDescription: Verify HandleOnAppStarted
364 */
365 HWTEST_F(AppSpawnSocketTest, HandleOnAppStarted_002, TestSize.Level0)
366 {
367 auto manager = std::make_shared<AppStateObserverManager>();
368 ASSERT_NE(manager, nullptr);
369 std::vector<std::string> bundleNameList;
370 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
371 std::string bundleName = "com.ohos.unittest";
372 appRecord->mainBundleName_ = bundleName;
373 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
374 manager->HandleOnAppStarted(appRecord);
375 }
376
377 /*
378 * Feature: AppStateObserverManager
379 * Function: HandleOnAppStarted
380 * SubFunction: NA
381 * FunctionPoints: AppStateObserverManager HandleOnAppStarted
382 * EnvConditions: NA
383 * CaseDescription: Verify HandleOnAppStarted
384 */
385 HWTEST_F(AppSpawnSocketTest, HandleOnAppStarted_003, TestSize.Level0)
386 {
387 auto manager = std::make_shared<AppStateObserverManager>();
388 ASSERT_NE(manager, nullptr);
389 std::vector<std::string> bundleNameList;
390 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
391 std::string bundleName1 = "com.ohos.unittest1";
392 std::string bundleName2 = "com.ohos.unittest2";
393 appRecord->mainBundleName_ = bundleName1;
394 bundleNameList.push_back(bundleName2);
395 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
396 manager->HandleOnAppStarted(appRecord);
397 }
398
399 /*
400 * Feature: AppStateObserverManager
401 * Function: HandleOnAppStarted
402 * SubFunction: NA
403 * FunctionPoints: AppStateObserverManager HandleOnAppStarted
404 * EnvConditions: NA
405 * CaseDescription: Verify HandleOnAppStarted
406 */
407 HWTEST_F(AppSpawnSocketTest, HandleOnAppStarted_004, TestSize.Level0)
408 {
409 auto manager = std::make_shared<AppStateObserverManager>();
410 ASSERT_NE(manager, nullptr);
411 std::vector<std::string> bundleNameList;
412 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
413 std::string bundleName = "com.ohos.unittest";
414 appRecord->mainBundleName_ = bundleName;
415 bundleNameList.push_back(bundleName);
416 manager->appStateObserverMap_.emplace(nullptr, bundleNameList);
417 manager->HandleOnAppStarted(appRecord);
418 }
419
420 /*
421 * Feature: AppStateObserverManager
422 * Function: HandleOnAppStopped
423 * SubFunction: NA
424 * FunctionPoints: AppStateObserverManager HandleOnAppStopped
425 * EnvConditions: NA
426 * CaseDescription: Verify HandleOnAppStopped
427 */
428 HWTEST_F(AppSpawnSocketTest, HandleOnAppStopped_001, TestSize.Level0)
429 {
430 auto manager = std::make_shared<AppStateObserverManager>();
431 ASSERT_NE(manager, nullptr);
432 manager->HandleOnAppStopped(nullptr);
433 std::vector<std::string> bundleNameList;
434 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
435 std::string bundleName = "com.ohos.unittest";
436 appRecord->mainBundleName_ = bundleName;
437 bundleNameList.push_back(bundleName);
438 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
439 manager->HandleOnAppStopped(appRecord);
440 }
441
442 /*
443 * Feature: AppStateObserverManager
444 * Function: HandleOnAppStopped
445 * SubFunction: NA
446 * FunctionPoints: AppStateObserverManager HandleOnAppStopped
447 * EnvConditions: NA
448 * CaseDescription: Verify HandleOnAppStopped
449 */
450 HWTEST_F(AppSpawnSocketTest, HandleOnAppStopped_002, TestSize.Level0)
451 {
452 auto manager = std::make_shared<AppStateObserverManager>();
453 ASSERT_NE(manager, nullptr);
454 std::vector<std::string> bundleNameList;
455 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
456 std::string bundleName = "com.ohos.unittest";
457 appRecord->mainBundleName_ = bundleName;
458 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
459 manager->HandleOnAppStopped(appRecord);
460 }
461
462 /*
463 * Feature: AppStateObserverManager
464 * Function: HandleOnAppStopped
465 * SubFunction: NA
466 * FunctionPoints: AppStateObserverManager HandleOnAppStopped
467 * EnvConditions: NA
468 * CaseDescription: Verify HandleOnAppStopped
469 */
470 HWTEST_F(AppSpawnSocketTest, HandleOnAppStopped_003, TestSize.Level0)
471 {
472 auto manager = std::make_shared<AppStateObserverManager>();
473 ASSERT_NE(manager, nullptr);
474 std::vector<std::string> bundleNameList;
475 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
476 std::string bundleName1 = "com.ohos.unittest1";
477 std::string bundleName2 = "com.ohos.unittest2";
478 appRecord->mainBundleName_ = bundleName1;
479 bundleNameList.push_back(bundleName2);
480 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
481 manager->HandleOnAppStopped(appRecord);
482 }
483
484 /*
485 * Feature: AppStateObserverManager
486 * Function: HandleOnAppStopped
487 * SubFunction: NA
488 * FunctionPoints: AppStateObserverManager HandleOnAppStopped
489 * EnvConditions: NA
490 * CaseDescription: Verify HandleOnAppStopped
491 */
492 HWTEST_F(AppSpawnSocketTest, HandleOnAppStopped_004, TestSize.Level0)
493 {
494 auto manager = std::make_shared<AppStateObserverManager>();
495 ASSERT_NE(manager, nullptr);
496 std::vector<std::string> bundleNameList;
497 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
498 std::string bundleName = "com.ohos.unittest";
499 appRecord->mainBundleName_ = bundleName;
500 bundleNameList.push_back(bundleName);
501 manager->appStateObserverMap_.emplace(nullptr, bundleNameList);
502 manager->HandleOnAppStopped(appRecord);
503 }
504
505 /*
506 * Feature: AppStateObserverManager
507 * Function: HandleAppStateChanged
508 * SubFunction: NA
509 * FunctionPoints: AppStateObserverManager HandleAppStateChanged
510 * EnvConditions: NA
511 * CaseDescription: Verify HandleAppStateChanged
512 */
513 HWTEST_F(AppSpawnSocketTest, HandleAppStateChanged_001, TestSize.Level0)
514 {
515 auto manager = std::make_shared<AppStateObserverManager>();
516 ASSERT_NE(manager, nullptr);
517 std::vector<std::string> bundleNameList;
518 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
519 ApplicationState state = ApplicationState::APP_STATE_FOREGROUND;
520 bool needNotifyApp = true;
521 std::string bundleName = "com.ohos.unittest";
522 appRecord->mainBundleName_ = bundleName;
523 bundleNameList.push_back(bundleName);
524 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
525 manager->HandleAppStateChanged(appRecord, state, needNotifyApp);
526 }
527
528 /*
529 * Feature: AppStateObserverManager
530 * Function: HandleAppStateChanged
531 * SubFunction: NA
532 * FunctionPoints: AppStateObserverManager HandleAppStateChanged
533 * EnvConditions: NA
534 * CaseDescription: Verify HandleAppStateChanged
535 */
536 HWTEST_F(AppSpawnSocketTest, HandleAppStateChanged_002, TestSize.Level0)
537 {
538 auto manager = std::make_shared<AppStateObserverManager>();
539 ASSERT_NE(manager, nullptr);
540 std::vector<std::string> bundleNameList;
541 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
542 ApplicationState state = ApplicationState::APP_STATE_BACKGROUND;
543 bool needNotifyApp = false;
544 std::string bundleName = "com.ohos.unittest";
545 appRecord->mainBundleName_ = bundleName;
546 bundleNameList.push_back(bundleName);
547 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
548 manager->HandleAppStateChanged(appRecord, state, needNotifyApp);
549 }
550
551 /*
552 * Feature: AppStateObserverManager
553 * Function: HandleAppStateChanged
554 * SubFunction: NA
555 * FunctionPoints: AppStateObserverManager HandleAppStateChanged
556 * EnvConditions: NA
557 * CaseDescription: Verify HandleAppStateChanged
558 */
559 HWTEST_F(AppSpawnSocketTest, HandleAppStateChanged_003, TestSize.Level0)
560 {
561 auto manager = std::make_shared<AppStateObserverManager>();
562 ASSERT_NE(manager, nullptr);
563 std::vector<std::string> bundleNameList;
564 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
565 ApplicationState state = ApplicationState::APP_STATE_BACKGROUND;
566 bool needNotifyApp = false;
567 std::string bundleName = "com.ohos.unittest";
568 appRecord->mainBundleName_ = bundleName;
569 manager->appStateObserverMap_.emplace(nullptr, bundleNameList);
570 manager->HandleAppStateChanged(appRecord, state, needNotifyApp);
571 }
572
573 /*
574 * Feature: AppStateObserverManager
575 * Function: HandleAppStateChanged
576 * SubFunction: NA
577 * FunctionPoints: AppStateObserverManager HandleAppStateChanged
578 * EnvConditions: NA
579 * CaseDescription: Verify HandleAppStateChanged
580 */
581 HWTEST_F(AppSpawnSocketTest, HandleAppStateChanged_004, TestSize.Level0)
582 {
583 auto manager = std::make_shared<AppStateObserverManager>();
584 ASSERT_NE(manager, nullptr);
585 std::vector<std::string> bundleNameList;
586 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
587 ApplicationState state = ApplicationState::APP_STATE_CREATE;
588 bool needNotifyApp = false;
589 std::string bundleName = "com.ohos.unittest";
590 appRecord->mainBundleName_ = bundleName;
591 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
592 manager->HandleAppStateChanged(appRecord, state, needNotifyApp);
593 }
594
595 /*
596 * Feature: AppStateObserverManager
597 * Function: HandleAppStateChanged
598 * SubFunction: NA
599 * FunctionPoints: AppStateObserverManager HandleAppStateChanged
600 * EnvConditions: NA
601 * CaseDescription: Verify HandleAppStateChanged
602 */
603 HWTEST_F(AppSpawnSocketTest, HandleAppStateChanged_005, TestSize.Level0)
604 {
605 auto manager = std::make_shared<AppStateObserverManager>();
606 ASSERT_NE(manager, nullptr);
607 std::vector<std::string> bundleNameList;
608 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
609 ApplicationState state = ApplicationState::APP_STATE_TERMINATED;
610 bool needNotifyApp = false;
611 std::string bundleName = "com.ohos.unittest";
612 appRecord->mainBundleName_ = bundleName;
613 bundleNameList.push_back(bundleName);
614 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
615 manager->HandleAppStateChanged(appRecord, state, needNotifyApp);
616 }
617
618 /*
619 * Feature: AppStateObserverManager
620 * Function: HandleAppStateChanged
621 * SubFunction: NA
622 * FunctionPoints: AppStateObserverManager HandleAppStateChanged
623 * EnvConditions: NA
624 * CaseDescription: Verify HandleAppStateChanged
625 */
626 HWTEST_F(AppSpawnSocketTest, HandleAppStateChanged_006, TestSize.Level0)
627 {
628 auto manager = std::make_shared<AppStateObserverManager>();
629 ASSERT_NE(manager, nullptr);
630 std::vector<std::string> bundleNameList;
631 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
632 ApplicationState state = ApplicationState::APP_STATE_CREATE;
633 bool needNotifyApp = false;
634 std::string bundleName1 = "com.ohos.unittest1";
635 std::string bundleName2 = "com.ohos.unittest2";
636 appRecord->mainBundleName_ = bundleName1;
637 bundleNameList.push_back(bundleName2);
638 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
639 manager->HandleAppStateChanged(appRecord, state, needNotifyApp);
640 }
641
642 /*
643 * Feature: AppStateObserverManager
644 * Function: HandleAppStateChanged
645 * SubFunction: NA
646 * FunctionPoints: AppStateObserverManager HandleAppStateChanged
647 * EnvConditions: NA
648 * CaseDescription: Verify HandleAppStateChanged
649 */
650 HWTEST_F(AppSpawnSocketTest, HandleAppStateChanged_007, TestSize.Level0)
651 {
652 auto manager = std::make_shared<AppStateObserverManager>();
653 ASSERT_NE(manager, nullptr);
654 std::vector<std::string> bundleNameList;
655 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
656 ApplicationState state = ApplicationState::APP_STATE_CREATE;
657 bool needNotifyApp = false;
658 std::string bundleName = "com.ohos.unittest";
659 appRecord->mainBundleName_ = bundleName;
660 manager->appStateObserverMap_.emplace(nullptr, bundleNameList);
661 manager->HandleAppStateChanged(appRecord, state, needNotifyApp);
662 }
663
664 /*
665 * Feature: AppStateObserverManager
666 * Function: HandleAppStateChanged
667 * SubFunction: NA
668 * FunctionPoints: AppStateObserverManager HandleAppStateChanged
669 * EnvConditions: NA
670 * CaseDescription: Verify HandleAppStateChanged
671 */
672 HWTEST_F(AppSpawnSocketTest, HandleAppStateChanged_008, TestSize.Level0)
673 {
674 auto manager = std::make_shared<AppStateObserverManager>();
675 ASSERT_NE(manager, nullptr);
676 std::vector<std::string> bundleNameList;
677 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
678 ApplicationState state = ApplicationState::APP_STATE_END;
679 bool needNotifyApp = false;
680 manager->HandleAppStateChanged(appRecord, state, needNotifyApp);
681 }
682
683 /*
684 * Feature: AppStateObserverManager
685 * Function: HandleStateChangedNotifyObserver
686 * SubFunction: NA
687 * FunctionPoints: AppStateObserverManager HandleStateChangedNotifyObserver
688 * EnvConditions: NA
689 * CaseDescription: Verify HandleStateChangedNotifyObserver
690 */
691 HWTEST_F(AppSpawnSocketTest, HandleStateChangedNotifyObserver_001, TestSize.Level0)
692 {
693 auto manager = std::make_shared<AppStateObserverManager>();
694 ASSERT_NE(manager, nullptr);
695 AbilityStateData abilityStateData;
696 bool isAbility = true;
697 std::vector<std::string> bundleNameList;
698 std::string bundleName = "com.ohos.unittest";
699 abilityStateData.bundleName = bundleName;
700 bundleNameList.push_back(bundleName);
701 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
702 manager->HandleStateChangedNotifyObserver(abilityStateData, isAbility);
703 }
704
705 /*
706 * Feature: AppStateObserverManager
707 * Function: HandleStateChangedNotifyObserver
708 * SubFunction: NA
709 * FunctionPoints: AppStateObserverManager HandleStateChangedNotifyObserver
710 * EnvConditions: NA
711 * CaseDescription: Verify HandleStateChangedNotifyObserver
712 */
713 HWTEST_F(AppSpawnSocketTest, HandleStateChangedNotifyObserver_002, TestSize.Level0)
714 {
715 auto manager = std::make_shared<AppStateObserverManager>();
716 ASSERT_NE(manager, nullptr);
717 AbilityStateData abilityStateData;
718 bool isAbility = false;
719 std::vector<std::string> bundleNameList;
720 std::string bundleName = "com.ohos.unittest";
721 abilityStateData.bundleName = bundleName;
722 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
723 manager->HandleStateChangedNotifyObserver(abilityStateData, isAbility);
724 }
725
726 /*
727 * Feature: AppStateObserverManager
728 * Function: HandleStateChangedNotifyObserver
729 * SubFunction: NA
730 * FunctionPoints: AppStateObserverManager HandleStateChangedNotifyObserver
731 * EnvConditions: NA
732 * CaseDescription: Verify HandleStateChangedNotifyObserver
733 */
734 HWTEST_F(AppSpawnSocketTest, HandleStateChangedNotifyObserver_003, TestSize.Level0)
735 {
736 auto manager = std::make_shared<AppStateObserverManager>();
737 ASSERT_NE(manager, nullptr);
738 AbilityStateData abilityStateData;
739 bool isAbility = false;
740 std::vector<std::string> bundleNameList;
741 std::string bundleName1 = "com.ohos.unittest1";
742 std::string bundleName2 = "com.ohos.unittest2";
743 abilityStateData.bundleName = bundleName1;
744 bundleNameList.push_back(bundleName2);
745 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
746 manager->HandleStateChangedNotifyObserver(abilityStateData, isAbility);
747 }
748
749 /*
750 * Feature: AppStateObserverManager
751 * Function: HandleStateChangedNotifyObserver
752 * SubFunction: NA
753 * FunctionPoints: AppStateObserverManager HandleStateChangedNotifyObserver
754 * EnvConditions: NA
755 * CaseDescription: Verify HandleStateChangedNotifyObserver
756 */
757 HWTEST_F(AppSpawnSocketTest, HandleStateChangedNotifyObserver_004, TestSize.Level0)
758 {
759 auto manager = std::make_shared<AppStateObserverManager>();
760 ASSERT_NE(manager, nullptr);
761 AbilityStateData abilityStateData;
762 bool isAbility = false;
763 std::vector<std::string> bundleNameList;
764 std::string bundleName = "com.ohos.unittest";
765 abilityStateData.bundleName = bundleName;
766 bundleNameList.push_back(bundleName);
767 manager->appStateObserverMap_.emplace(nullptr, bundleNameList);
768 manager->HandleStateChangedNotifyObserver(abilityStateData, isAbility);
769 }
770
771 /*
772 * Feature: AppStateObserverManager
773 * Function: HandleOnAppProcessCreated
774 * SubFunction: NA
775 * FunctionPoints: AppStateObserverManager HandleOnAppProcessCreated
776 * EnvConditions: NA
777 * CaseDescription: Verify HandleOnAppProcessCreated
778 */
779 HWTEST_F(AppSpawnSocketTest, HandleOnAppProcessCreated_001, TestSize.Level0)
780 {
781 auto manager = std::make_shared<AppStateObserverManager>();
782 ASSERT_NE(manager, nullptr);
783 manager->HandleOnAppProcessCreated(nullptr);
784 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
785 manager->HandleOnAppProcessCreated(appRecord);
786 }
787
788 /*
789 * Feature: AppStateObserverManager
790 * Function: HandleOnRenderProcessCreated
791 * SubFunction: NA
792 * FunctionPoints: AppStateObserverManager HandleOnRenderProcessCreated
793 * EnvConditions: NA
794 * CaseDescription: Verify HandleOnRenderProcessCreated
795 */
796 HWTEST_F(AppSpawnSocketTest, HandleOnRenderProcessCreated_001, TestSize.Level0)
797 {
798 auto manager = std::make_shared<AppStateObserverManager>();
799 ASSERT_NE(manager, nullptr);
800 manager->HandleOnRenderProcessCreated(nullptr);
801 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
802 std::shared_ptr<RenderRecord> renderRecord =
803 std::make_shared<RenderRecord>(1, "param", 1, 1, 1, appRecord);
804 renderRecord->SetPid(1);
805 manager->HandleOnRenderProcessCreated(renderRecord);
806 }
807
808 /*
809 * Feature: AppStateObserverManager
810 * Function: HandleOnProcessCreated
811 * SubFunction: NA
812 * FunctionPoints: AppStateObserverManager HandleOnProcessCreated
813 * EnvConditions: NA
814 * CaseDescription: Verify HandleOnProcessCreated
815 */
816 HWTEST_F(AppSpawnSocketTest, HandleOnProcessCreated_001, TestSize.Level0)
817 {
818 auto manager = std::make_shared<AppStateObserverManager>();
819 ASSERT_NE(manager, nullptr);
820 ProcessData data;
821 std::vector<std::string> bundleNameList;
822 std::string bundleName = "com.ohos.unittest";
823 data.bundleName = bundleName;
824 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
825 manager->HandleOnProcessCreated(data);
826 }
827
828 /*
829 * Feature: AppStateObserverManager
830 * Function: HandleOnProcessCreated
831 * SubFunction: NA
832 * FunctionPoints: AppStateObserverManager HandleOnProcessCreated
833 * EnvConditions: NA
834 * CaseDescription: Verify HandleOnProcessCreated
835 */
836 HWTEST_F(AppSpawnSocketTest, HandleOnProcessCreated_002, TestSize.Level0)
837 {
838 auto manager = std::make_shared<AppStateObserverManager>();
839 ASSERT_NE(manager, nullptr);
840 ProcessData data;
841 std::vector<std::string> bundleNameList;
842 std::string bundleName = "com.ohos.unittest";
843 data.bundleName = bundleName;
844 bundleNameList.push_back(bundleName);
845 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
846 manager->HandleOnProcessCreated(data);
847 }
848
849 /*
850 * Feature: AppStateObserverManager
851 * Function: HandleOnProcessCreated
852 * SubFunction: NA
853 * FunctionPoints: AppStateObserverManager HandleOnProcessCreated
854 * EnvConditions: NA
855 * CaseDescription: Verify HandleOnProcessCreated
856 */
857 HWTEST_F(AppSpawnSocketTest, HandleOnProcessCreated_003, TestSize.Level0)
858 {
859 auto manager = std::make_shared<AppStateObserverManager>();
860 ASSERT_NE(manager, nullptr);
861 ProcessData data;
862 std::vector<std::string> bundleNameList;
863 std::string bundleName1 = "com.ohos.unittest";
864 std::string bundleName2 = "com.ohos.unittest";
865 data.bundleName = bundleName1;
866 bundleNameList.push_back(bundleName2);
867 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
868 manager->HandleOnProcessCreated(data);
869 }
870
871 /*
872 * Feature: AppStateObserverManager
873 * Function: HandleOnProcessCreated
874 * SubFunction: NA
875 * FunctionPoints: AppStateObserverManager HandleOnProcessCreated
876 * EnvConditions: NA
877 * CaseDescription: Verify HandleOnProcessCreated
878 */
879 HWTEST_F(AppSpawnSocketTest, HandleOnProcessCreated_004, TestSize.Level0)
880 {
881 auto manager = std::make_shared<AppStateObserverManager>();
882 ASSERT_NE(manager, nullptr);
883 ProcessData data;
884 std::vector<std::string> bundleNameList;
885 std::string bundleName = "com.ohos.unittest";
886 data.bundleName = bundleName;
887 bundleNameList.push_back(bundleName);
888 manager->appStateObserverMap_.emplace(nullptr, bundleNameList);
889 manager->HandleOnProcessCreated(data);
890 }
891
892 /*
893 * Feature: AppStateObserverManager
894 * Function: HandleOnProcessStateChanged
895 * SubFunction: NA
896 * FunctionPoints: AppStateObserverManager HandleOnProcessStateChanged
897 * EnvConditions: NA
898 * CaseDescription: Verify HandleOnProcessStateChanged
899 */
900 HWTEST_F(AppSpawnSocketTest, HandleOnProcessStateChanged_001, TestSize.Level0)
901 {
902 auto manager = std::make_shared<AppStateObserverManager>();
903 ASSERT_NE(manager, nullptr);
904 manager->HandleOnProcessStateChanged(nullptr);
905 }
906
907 /*
908 * Feature: AppStateObserverManager
909 * Function: HandleOnProcessStateChanged
910 * SubFunction: NA
911 * FunctionPoints: AppStateObserverManager HandleOnProcessStateChanged
912 * EnvConditions: NA
913 * CaseDescription: Verify HandleOnProcessStateChanged
914 */
915 HWTEST_F(AppSpawnSocketTest, HandleOnProcessStateChanged_002, TestSize.Level0)
916 {
917 auto manager = std::make_shared<AppStateObserverManager>();
918 ASSERT_NE(manager, nullptr);
919 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
920 std::vector<std::string> bundleNameList;
921 std::string bundleName = "com.ohos.unittest";
922 appRecord->mainBundleName_ = bundleName;
923 bundleNameList.push_back(bundleName);
924 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
925 manager->HandleOnProcessStateChanged(appRecord);
926 }
927
928 /*
929 * Feature: AppStateObserverManager
930 * Function: HandleOnProcessStateChanged
931 * SubFunction: NA
932 * FunctionPoints: AppStateObserverManager HandleOnProcessStateChanged
933 * EnvConditions: NA
934 * CaseDescription: Verify HandleOnProcessStateChanged
935 */
936 HWTEST_F(AppSpawnSocketTest, HandleOnProcessStateChanged_003, TestSize.Level0)
937 {
938 auto manager = std::make_shared<AppStateObserverManager>();
939 ASSERT_NE(manager, nullptr);
940 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
941 std::vector<std::string> bundleNameList;
942 std::string bundleName = "com.ohos.unittest";
943 appRecord->mainBundleName_ = bundleName;
944 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
945 manager->HandleOnProcessStateChanged(appRecord);
946 }
947
948 /*
949 * Feature: AppStateObserverManager
950 * Function: HandleOnProcessStateChanged
951 * SubFunction: NA
952 * FunctionPoints: AppStateObserverManager HandleOnProcessStateChanged
953 * EnvConditions: NA
954 * CaseDescription: Verify HandleOnProcessStateChanged
955 */
956 HWTEST_F(AppSpawnSocketTest, HandleOnProcessStateChanged_004, TestSize.Level0)
957 {
958 auto manager = std::make_shared<AppStateObserverManager>();
959 ASSERT_NE(manager, nullptr);
960 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
961 std::vector<std::string> bundleNameList;
962 std::string bundleName1 = "com.ohos.unittest1";
963 std::string bundleName2 = "com.ohos.unittest2";
964 appRecord->mainBundleName_ = bundleName1;
965 bundleNameList.push_back(bundleName2);
966 manager->appStateObserverMap_.emplace(nullptr, bundleNameList);
967 manager->HandleOnProcessStateChanged(appRecord);
968 }
969
970 /*
971 * Feature: AppStateObserverManager
972 * Function: HandleOnProcessStateChanged
973 * SubFunction: NA
974 * FunctionPoints: AppStateObserverManager HandleOnProcessStateChanged
975 * EnvConditions: NA
976 * CaseDescription: Verify HandleOnProcessStateChanged
977 */
978 HWTEST_F(AppSpawnSocketTest, HandleOnProcessStateChanged_005, TestSize.Level0)
979 {
980 auto manager = std::make_shared<AppStateObserverManager>();
981 ASSERT_NE(manager, nullptr);
982 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
983 std::vector<std::string> bundleNameList;
984 std::string bundleName = "com.ohos.unittest";
985 appRecord->mainBundleName_ = bundleName;
986 bundleNameList.push_back(bundleName);
987 manager->appStateObserverMap_.emplace(nullptr, bundleNameList);
988 manager->HandleOnProcessStateChanged(appRecord);
989 }
990
991 /*
992 * Feature: AppStateObserverManager
993 * Function: HandleOnAppProcessDied
994 * SubFunction: NA
995 * FunctionPoints: AppStateObserverManager HandleOnAppProcessDied
996 * EnvConditions: NA
997 * CaseDescription: Verify HandleOnAppProcessDied
998 */
999 HWTEST_F(AppSpawnSocketTest, HandleOnAppProcessDied_001, TestSize.Level0)
1000 {
1001 auto manager = std::make_shared<AppStateObserverManager>();
1002 ASSERT_NE(manager, nullptr);
1003 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
1004 manager->HandleOnAppProcessDied(nullptr);
1005 manager->HandleOnAppProcessDied(appRecord);
1006 }
1007
1008 /*
1009 * Feature: AppStateObserverManager
1010 * Function: HandleOnRenderProcessDied
1011 * SubFunction: NA
1012 * FunctionPoints: AppStateObserverManager HandleOnRenderProcessDied
1013 * EnvConditions: NA
1014 * CaseDescription: Verify HandleOnRenderProcessDied
1015 */
1016 HWTEST_F(AppSpawnSocketTest, HandleOnRenderProcessDied_001, TestSize.Level0)
1017 {
1018 auto manager = std::make_shared<AppStateObserverManager>();
1019 ASSERT_NE(manager, nullptr);
1020 std::shared_ptr<AppRunningRecord> appRecord = MockAppRecord();
1021 std::shared_ptr<RenderRecord> renderRecord =
1022 std::make_shared<RenderRecord>(1, "param", 1, 1, 1, appRecord);
1023 renderRecord->SetPid(1);
1024 manager->HandleOnRenderProcessDied(nullptr);
1025 manager->HandleOnRenderProcessDied(renderRecord);
1026 }
1027
1028 /*
1029 * Feature: AppStateObserverManager
1030 * Function: HandleOnProcessDied
1031 * SubFunction: NA
1032 * FunctionPoints: AppStateObserverManager HandleOnProcessDied
1033 * EnvConditions: NA
1034 * CaseDescription: Verify HandleOnProcessDied
1035 */
1036 HWTEST_F(AppSpawnSocketTest, HandleOnProcessDied_001, TestSize.Level0)
1037 {
1038 auto manager = std::make_shared<AppStateObserverManager>();
1039 ASSERT_NE(manager, nullptr);
1040 ProcessData data;
1041 std::vector<std::string> bundleNameList;
1042 std::string bundleName = "com.ohos.unittest";
1043 data.bundleName = bundleName;
1044 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
1045 manager->HandleOnProcessDied(data);
1046 }
1047
1048 /*
1049 * Feature: AppStateObserverManager
1050 * Function: HandleOnProcessDied
1051 * SubFunction: NA
1052 * FunctionPoints: AppStateObserverManager HandleOnProcessDied
1053 * EnvConditions: NA
1054 * CaseDescription: Verify HandleOnProcessDied
1055 */
1056 HWTEST_F(AppSpawnSocketTest, HandleOnProcessDied_002, TestSize.Level0)
1057 {
1058 auto manager = std::make_shared<AppStateObserverManager>();
1059 ASSERT_NE(manager, nullptr);
1060 ProcessData data;
1061 std::vector<std::string> bundleNameList;
1062 std::string bundleName = "com.ohos.unittest";
1063 data.bundleName = bundleName;
1064 bundleNameList.push_back(bundleName);
1065 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
1066 manager->HandleOnProcessDied(data);
1067 }
1068
1069 /*
1070 * Feature: AppStateObserverManager
1071 * Function: HandleOnProcessDied
1072 * SubFunction: NA
1073 * FunctionPoints: AppStateObserverManager HandleOnProcessDied
1074 * EnvConditions: NA
1075 * CaseDescription: Verify HandleOnProcessDied
1076 */
1077 HWTEST_F(AppSpawnSocketTest, HandleOnProcessDied_003, TestSize.Level0)
1078 {
1079 auto manager = std::make_shared<AppStateObserverManager>();
1080 ASSERT_NE(manager, nullptr);
1081 ProcessData data;
1082 std::vector<std::string> bundleNameList;
1083 std::string bundleName1 = "com.ohos.unittest1";
1084 std::string bundleName2 = "com.ohos.unittest2";
1085 data.bundleName = bundleName1;
1086 bundleNameList.push_back(bundleName2);
1087 manager->appStateObserverMap_.emplace(observer_, bundleNameList);
1088 manager->HandleOnProcessDied(data);
1089 }
1090
1091 /*
1092 * Feature: AppStateObserverManager
1093 * Function: HandleOnProcessDied
1094 * SubFunction: NA
1095 * FunctionPoints: AppStateObserverManager HandleOnProcessDied
1096 * EnvConditions: NA
1097 * CaseDescription: Verify HandleOnProcessDied
1098 */
1099 HWTEST_F(AppSpawnSocketTest, HandleOnProcessDied_004, TestSize.Level0)
1100 {
1101 auto manager = std::make_shared<AppStateObserverManager>();
1102 ASSERT_NE(manager, nullptr);
1103 ProcessData data;
1104 std::vector<std::string> bundleNameList;
1105 std::string bundleName1 = "com.ohos.unittest1";
1106 std::string bundleName2 = "com.ohos.unittest2";
1107 data.bundleName = bundleName1;
1108 bundleNameList.push_back(bundleName2);
1109 manager->appStateObserverMap_.emplace(nullptr, bundleNameList);
1110 manager->HandleOnProcessDied(data);
1111 }
1112
1113 /*
1114 * Feature: AppStateObserverManager
1115 * Function: ObserverExist
1116 * SubFunction: NA
1117 * FunctionPoints: AppStateObserverManager ObserverExist
1118 * EnvConditions: NA
1119 * CaseDescription: Verify ObserverExist
1120 */
1121 HWTEST_F(AppSpawnSocketTest, ObserverExist_001, TestSize.Level0)
1122 {
1123 auto manager = std::make_shared<AppStateObserverManager>();
1124 bool res = manager->ObserverExist(nullptr);
1125 EXPECT_FALSE(res);
1126 }
1127
1128 /*
1129 * Feature: AppStateObserverManager
1130 * Function: ObserverExist
1131 * SubFunction: NA
1132 * FunctionPoints: AppStateObserverManager ObserverExist
1133 * EnvConditions: NA
1134 * CaseDescription: Verify ObserverExist
1135 */
1136 HWTEST_F(AppSpawnSocketTest, ObserverExist_002, TestSize.Level0)
1137 {
1138 auto manager = std::make_shared<AppStateObserverManager>();
1139 sptr<IApplicationStateObserver> observer = new MockApplicationStateObserver();
1140 std::vector<std::string> bundleNameList;
1141 manager->appStateObserverMap_.emplace(observer, bundleNameList);
1142 bool res = manager->ObserverExist(observer);
1143 EXPECT_TRUE(res);
1144 }
1145
1146 /*
1147 * Feature: AppStateObserverManager
1148 * Function: AddObserverDeathRecipient
1149 * SubFunction: NA
1150 * FunctionPoints: AppStateObserverManager AddObserverDeathRecipient
1151 * EnvConditions: NA
1152 * CaseDescription: Verify AddObserverDeathRecipient
1153 */
1154 HWTEST_F(AppSpawnSocketTest, AddObserverDeathRecipient_001, TestSize.Level0)
1155 {
1156 auto manager = std::make_shared<AppStateObserverManager>();
1157 ASSERT_NE(manager, nullptr);
1158 manager->AddObserverDeathRecipient(nullptr);
1159 manager->AddObserverDeathRecipient(observer_);
1160 }
1161
1162 /*
1163 * Feature: AppStateObserverManager
1164 * Function: RemoveObserverDeathRecipient
1165 * SubFunction: NA
1166 * FunctionPoints: AppStateObserverManager RemoveObserverDeathRecipient
1167 * EnvConditions: NA
1168 * CaseDescription: Verify RemoveObserverDeathRecipient
1169 */
1170 HWTEST_F(AppSpawnSocketTest, RemoveObserverDeathRecipient_001, TestSize.Level0)
1171 {
1172 auto manager = std::make_shared<AppStateObserverManager>();
1173 ASSERT_NE(manager, nullptr);
1174 manager->RemoveObserverDeathRecipient(nullptr);
1175 manager->AddObserverDeathRecipient(observer_);
1176 }
1177 } // namespace AppExecFwk
1178 } // namespace OHOS
1179