1 /*
2  * Copyright (c) 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 "intention_event/service/anr_manager/include/anr_manager.h"
17 #include <gtest/gtest.h>
18 
19 using namespace testing;
20 using namespace testing::ext;
21 
22 namespace OHOS {
23 namespace Rosen {
24 constexpr int32_t MAX_ANR_TIMER_COUNT { 64 };
25 class AnrManagerTest : public testing::Test {
26 public:
SetUpTestCase(void)27     static void SetUpTestCase(void) {}
TearDownTestCase(void)28     static void TearDownTestCase(void) {}
29 };
30 
31 namespace {
32 /**
33  * @tc.name: AddTimer
34  * @tc.desc: AddTimer
35  * @tc.type: FUNC
36  * @tc.require:
37  */
38 HWTEST_F(AnrManagerTest, AddTimer, Function | SmallTest | Level1)
39 {
40     int ret = 0;
41     Rosen::ANRManager anrMgr;
42     bool switcherTemp = anrMgr.switcher_;
43     anrMgr.switcher_ = false;
44     anrMgr.AddTimer(0, 1);
45 
46     anrMgr.switcher_ = true;
47     anrMgr.anrTimerCount_ = MAX_ANR_TIMER_COUNT;
48     anrMgr.AddTimer(0, 1);
49 
50     anrMgr.anrTimerCount_ = 0;
51     anrMgr.AddTimer(0, 1);
52     anrMgr.switcher_ = switcherTemp;
53     ASSERT_EQ(ret, 0);
54 }
55 
56 /**
57  * @tc.name: IsANRTriggered
58  * @tc.desc: IsANRTriggered
59  * @tc.type: FUNC
60  * @tc.require:
61  */
62 HWTEST_F(AnrManagerTest, IsANRTriggered, Function | SmallTest | Level1)
63 {
64     Rosen::ANRManager anrMgr;
65     bool ret = anrMgr.IsANRTriggered(0);
66     ASSERT_EQ(ret, false);
67 
68     DelayedSingleton<EventStage>::GetInstance()->isAnrProcess_.emplace(123, true);
69     ret = anrMgr.IsANRTriggered(123);
70     ASSERT_EQ(ret, true);
71 
72     DelayedSingleton<EventStage>::GetInstance()->isAnrProcess_.emplace(156, false);
73     ret = anrMgr.IsANRTriggered(156);
74     ASSERT_EQ(ret, false);
75 }
76 
77 /**
78  * @tc.name: RemoveTimers
79  * @tc.desc: RemoveTimers
80  * @tc.type: FUNC
81  * @tc.require:
82  */
83 HWTEST_F(AnrManagerTest, RemoveTimers, Function | SmallTest | Level1)
84 {
85     int ret = 0;
86     Rosen::ANRManager anrMgr;
87     anrMgr.RemoveTimers(1);
88     std::vector<EventStage::EventTime> events;
89     DelayedSingleton<EventStage>::GetInstance()->events_.emplace(1, events);
90     DelayedSingleton<EventStage>::GetInstance()->events_.emplace(2, events);
91     anrMgr.RemoveTimers(2);
92     ASSERT_EQ(ret, 0);
93 }
94 
95 /**
96  * @tc.name: GetAppInfoByPersistentId
97  * @tc.desc: GetAppInfoByPersistentId
98  * @tc.type: FUNC
99  * @tc.require:
100  */
101 HWTEST_F(AnrManagerTest, GetAppInfoByPersistentId, Function | SmallTest | Level1)
102 {
103     Rosen::ANRManager::AppInfo appInfo;
104     Rosen::ANRManager anrMgr;
105     auto ret = anrMgr.GetAppInfoByPersistentId(0);
106     ASSERT_EQ(ret.pid, -1);
107 
108     appInfo.pid = 123;
109     anrMgr.applicationMap_.emplace(0, appInfo);
110     ret = anrMgr.GetAppInfoByPersistentId(0);
111     ASSERT_EQ(ret.pid, 123);
112 }
113 
114 /**
115  * @tc.name: SwitchAnr
116  * @tc.desc: SwitchAnr
117  * @tc.type: FUNC
118  * @tc.require:
119  */
120 HWTEST_F(AnrManagerTest, SwitchAnr, Function | SmallTest | Level1)
121 {
122     Rosen::ANRManager anrMgr;
123     anrMgr.SwitchAnr(true);
124     ASSERT_EQ(anrMgr.switcher_, true);
125 
126     anrMgr.SwitchAnr(false);
127     ASSERT_EQ(anrMgr.switcher_, false);
128 }
129 
130 /**
131  * @tc.name: GetBundleName
132  * @tc.desc: GetBundleName
133  * @tc.type: FUNC
134  * @tc.require:
135  */
136 HWTEST_F(AnrManagerTest, GetBundleName, Function | SmallTest | Level1)
137 {
138     Rosen::ANRManager anrMgr;
139     auto ret = anrMgr.GetBundleName(0, 0);
140     ASSERT_EQ(ret, "unknown");
141 
__anon24b779ec0202(int32_t pid, std::string& bundleName, int32_t uid) 142     anrMgr.appInfoGetter_ = [](int32_t pid, std::string& bundleName, int32_t uid) {
143         bundleName = std::to_string(pid) + std::to_string(uid);
144     };
145     ret = anrMgr.GetBundleName(1, 2);
146     ASSERT_EQ(ret, "12");
147 }
148 
149 /**
150  * @tc.name: ExecuteAnrObserver
151  * @tc.desc: ExecuteAnrObserver
152  * @tc.type: FUNC
153  * @tc.require:
154  */
155 HWTEST_F(AnrManagerTest, ExecuteAnrObserver, Function | SmallTest | Level1)
156 {
157     Rosen::ANRManager anrMgr;
158     anrMgr.anrObserver_ = nullptr;
159     anrMgr.ExecuteAnrObserver(1);
160     ASSERT_EQ(anrMgr.anrObserver_, nullptr);
161     int32_t ret = 0;
__anon24b779ec0302(int32_t pid) 162     anrMgr.anrObserver_ = [&ret](int32_t pid) {
163         ret = pid;
164     };
165     anrMgr.ExecuteAnrObserver(123);
166     ASSERT_EQ(ret, 123);
167 }
168 }
169 }
170 } // namespace OHOS