1 /*
2 * Copyright (c) 2021 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 "xcollie_watchdog_test.h"
17
18 #include <gtest/gtest.h>
19 #include <string>
20
21 #include "xcollie.h"
22 #include "xcollie_checker_test.h"
23 #include "xcollie_define.h"
24 #include "xcollie_inner.h"
25 #include "xcollie_utils.h"
26
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace HiviewDFX {
SetUpTestCase(void)31 void XCollieWatchdogTest::SetUpTestCase(void)
32 {
33 }
34
TearDownTestCase(void)35 void XCollieWatchdogTest::TearDownTestCase(void)
36 {
37 }
38
SetUp(void)39 void XCollieWatchdogTest::SetUp(void)
40 {
41 }
42
TearDown(void)43 void XCollieWatchdogTest::TearDown(void)
44 {
45 }
46
Init(const int timeout)47 void XCollieWatchdogTest::Init(const int timeout)
48 {
49 XCollieInner::GetInstance().SetCheckStatus(CheckStatus::COMPLETED);
50 XCollieInner::GetInstance().SetCheckerInterval(timeout);
51 XCollieInner::GetInstance().SetRecoveryFlag(false);
52 }
53
54 /**
55 * @tc.name: XCollieWatchdogNoBlockTest
56 * @tc.desc: Verify watchdog, registered service has no block.
57 * @tc.type: FUNC
58 * @tc.require: SR000CPN2F AR000CTAMB
59 * @tc.author: yangjing
60 */
61 HWTEST_F(XCollieWatchdogTest, XCollieWatchdogNoBlock_001, TestSize.Level2)
62 {
63 int timeout = 1;
64 XCOLLIE_LOGI("XCollieWatchdogNoBlockTest start...");
65
66 /**
67 * @tc.steps: step1.init watchdog interval
68 */
69 Init(timeout);
70
71 /**
72 * @tc.steps: step2. register service, monitor thread and lock
73 */
74 sptr<XCollieCheckerTest> checkerTest = new XCollieCheckerTest("CheckerTest_NoBlock_001");
75 XCollie::GetInstance().RegisterXCollieChecker(checkerTest, XCOLLIE_LOCK | XCOLLIE_THREAD);
76
77 /**
78 * @tc.steps: step3. check watchdog could call service's callback
79 * @tc.expected: step3. watchdog calls service's callback successfully
80 */
81 std::this_thread::sleep_for(std::chrono::seconds(5));
82 EXPECT_GE(checkerTest->GetTestLockNumber(), 2);
83 EXPECT_GE(checkerTest->GetTestThreadNumber(), 2);
84 XCollieInner::GetInstance().UnRegisterXCollieChecker(checkerTest);
85 checkerTest = nullptr;
86 }
87
88 /**
89 * @tc.name: XCollieWatchdogBlockHalfTest
90 * @tc.desc: Verify watchdog, registered service has half block.
91 * @tc.type: FUNC
92 * @tc.require: SR000CPN2F AR000CTAMB
93 * @tc.author: yangjing
94 */
95 HWTEST_F(XCollieWatchdogTest, XCollieWatchdogBlockHalf_002, TestSize.Level2)
96 {
97 int timeout = 1;
98
99 XCOLLIE_LOGI("XCollieWatchdogBlockHalfTest start...");
100
101 /**
102 * @tc.steps: step1.init watchdog interval
103 */
104 Init(timeout);
105 /**
106 * @tc.steps: step2. register service, monitor lock
107 */
108 sptr<XCollieCheckerTest> checkerTest = new XCollieCheckerTest("CheckerTest_BlockHalf_002");
109 checkerTest->SetBlockTime(1);
110 XCollie::GetInstance().RegisterXCollieChecker(checkerTest, XCOLLIE_LOCK);
111
112 /**
113 * @tc.steps: step3. check watchdog could call service's callback
114 * @tc.expected: step3. watchdog calls service's callback successfully
115 */
116 std::this_thread::sleep_for(std::chrono::seconds(5));
117 EXPECT_GE(checkerTest->GetTestLockNumber(), 2);
118 XCollieInner::GetInstance().UnRegisterXCollieChecker(checkerTest);
119 checkerTest = nullptr;
120 }
121
122 /**
123 * @tc.name: XCollieWatchdogOneServiceBlockTest
124 * @tc.desc: Verify watchdog, registered service has thread block.
125 * @tc.type: FUNC
126 * @tc.require: SR000CPN2F AR000CTAMB
127 * @tc.author: yangjing
128 */
129 HWTEST_F(XCollieWatchdogTest, XCollieWatchdogOneServiceBlockTest_003, TestSize.Level3)
130 {
131 int timeout = 1;
132
133 XCOLLIE_LOGI("XCollieWatchdogOneServiceBlockTest start...");
134
135 /**
136 * @tc.steps: step1.init watchdog interval
137 */
138 Init(timeout);
139
140 /**
141 * @tc.steps: step2. register service, monitor lock
142 */
143 sptr<XCollieCheckerTest> checkerTest = new XCollieCheckerTest("CheckerTest_Block_003");
144 checkerTest->SetBlockTime(5);
145 XCollie::GetInstance().RegisterXCollieChecker(checkerTest, XCOLLIE_THREAD);
146 std::this_thread::sleep_for(std::chrono::seconds(4));
147
148 /**
149 * @tc.steps: step3. check watchdog could call service's callback, and monitor service lock
150 * @tc.expected: step3. watchdog calls service's callback successfully
151 * @tc.expected: step3. watchdog monitor service lock
152 */
153 EXPECT_EQ(checkerTest->GetTestThreadNumber(), 1);
154 EXPECT_EQ(XCollieInner::GetInstance().GetBlockdServiceName() == "CheckerTest_Block_003", true);
155 XCollieInner::GetInstance().UnRegisterXCollieChecker(checkerTest);
156 checkerTest = nullptr;
157 }
158
159
160 /**
161 * @tc.name: XCollieWatchdogTwoServiceThreadBlock
162 * @tc.desc: Verify watchdog, register two services, and one service has thread block.
163 * @tc.type: FUNC
164 * @tc.require: SR000CPN2F AR000CTAMB
165 * @tc.author: yangjing
166 */
167 HWTEST_F(XCollieWatchdogTest, XCollieWatchdogTwoServiceThreadBlock_004, TestSize.Level3)
168 {
169 int timeout = 1;
170
171 XCOLLIE_LOGI("XCollieWatchdogTwoServiceThreadBlock start...");
172
173 /**
174 * @tc.steps: step1.init watchdog interval
175 */
176 Init(timeout);
177
178 /**
179 * @tc.steps: step2. register two services, monitor lock
180 */
181 sptr<XCollieCheckerTest> checkerThreadTest = new XCollieCheckerTest("CheckerTest_ThreadBlock_004");
182 checkerThreadTest->SetBlockTime(5);
183 XCollie::GetInstance().RegisterXCollieChecker(checkerThreadTest, XCOLLIE_THREAD);
184
185 sptr<XCollieCheckerTest> checkerLockTest = new XCollieCheckerTest("CheckerTest_LockBlock_004");
186 checkerLockTest->SetBlockTime(0);
187 XCollie::GetInstance().RegisterXCollieChecker(checkerLockTest, XCOLLIE_LOCK);
188 std::this_thread::sleep_for(std::chrono::seconds(4));
189
190 /**
191 * @tc.steps: step3. check watchdog could call service's callback, and monitor service lock
192 * @tc.expected: step3. watchdog calls service's callback successfully
193 * @tc.expected: step3. watchdog monitor service lock
194 */
195 EXPECT_GE(checkerThreadTest->GetTestThreadNumber(), 1);
196 EXPECT_GE(checkerLockTest->GetTestLockNumber(), 1);
197 EXPECT_EQ(XCollieInner::GetInstance().GetBlockdServiceName() == "CheckerTest_ThreadBlock_004", true);
198 XCollieInner::GetInstance().UnRegisterXCollieChecker(checkerThreadTest);
199 XCollieInner::GetInstance().UnRegisterXCollieChecker(checkerLockTest);
200 checkerThreadTest = nullptr;
201 checkerLockTest = nullptr;
202 }
203
204 /**
205 * @tc.name: XCollieWatchdogTestTwoServiceLockBlock
206 * @tc.desc: Verify watchdog, register two services, and one service has lock block.
207 * @tc.type: FUNC
208 * @tc.require: AR000CVLGG
209 * @tc.author: yangjing
210 */
211 HWTEST_F(XCollieWatchdogTest, XCollieWatchdogTestTwoServiceLockBlock_005, TestSize.Level3)
212 {
213 int timeout = 1;
214
215 XCOLLIE_LOGI("XCollieWatchdogTestTwoServiceLockBlock start...");
216
217 /**
218 * @tc.steps: step1.init watchdog interval
219 */
220 Init(timeout);
221
222 /**
223 * @tc.steps: step2. register two services, monitor lock
224 */
225 sptr<XCollieCheckerTest> checkerThreadTest = new XCollieCheckerTest("CheckerTest_ThreadBlock_005");
226 checkerThreadTest->SetBlockTime(0);
227 XCollie::GetInstance().RegisterXCollieChecker(checkerThreadTest, XCOLLIE_THREAD);
228
229 sptr<XCollieCheckerTest> checkerLockTest = new XCollieCheckerTest("CheckerTest_LockBlock_005");
230 checkerLockTest->SetBlockTime(6);
231 XCollie::GetInstance().RegisterXCollieChecker(checkerLockTest, XCOLLIE_LOCK);
232 std::this_thread::sleep_for(std::chrono::seconds(4));
233
234 /**
235 * @tc.steps: step3. check watchdog could call service's callback, and monitor service lock
236 * @tc.expected: step3. watchdog calls service's callback successfully
237 * @tc.expected: step3. watchdog monitor service lock
238 */
239 EXPECT_GE(checkerThreadTest->GetTestThreadNumber(), 1);
240 EXPECT_GE(checkerLockTest->GetTestLockNumber(), 1);
241 EXPECT_EQ(XCollieInner::GetInstance().GetBlockdServiceName() == "CheckerTest_LockBlock_005", true);
242 XCollieInner::GetInstance().UnRegisterXCollieChecker(checkerThreadTest);
243 XCollieInner::GetInstance().UnRegisterXCollieChecker(checkerLockTest);
244 XCOLLIE_LOGI("XCollieWatchdogTestTwoServiceLockBlock exit...");
245 checkerThreadTest = nullptr;
246 checkerLockTest = nullptr;
247 }
248 } // end of namespace HiviewDFX
249 } // end of namespace OHOS
250