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 <gtest/gtest.h>
17 #include <string>
18 #include <thread>
19 #include <fstream>
20 #include <fcntl.h>
21 #include <sys/prctl.h>
22 #include <unistd.h>
23 #include <dlfcn.h>
24 #include <chrono>
25 #include <cstdio>
26 #include "watchdog_inner_test.h"
27
28 #define private public
29 #define protected public
30 #include "watchdog_inner.h"
31 #undef private
32 #undef protected
33
34 #include "xcollie_define.h"
35 #include "xcollie_utils.h"
36 #include "directory_ex.h"
37 #include "file_ex.h"
38 #include "event_handler.h"
39 #include "ffrt_inner.h"
40 #include "parameters.h"
41 #include "watchdog_inner_util_test.h"
42
43 using namespace testing::ext;
44 using namespace OHOS::AppExecFwk;
45 namespace OHOS {
46 namespace HiviewDFX {
SetUpTestCase(void)47 void WatchdogInnerTest::SetUpTestCase(void)
48 {
49 }
50
TearDownTestCase(void)51 void WatchdogInnerTest::TearDownTestCase(void)
52 {
53 }
54
SetUp(void)55 void WatchdogInnerTest::SetUp(void)
56 {
57 InitSeLinuxEnabled();
58 }
59
TearDown(void)60 void WatchdogInnerTest::TearDown(void)
61 {
62 CancelSeLinuxEnabled();
63 }
64
InitBeginFuncTest(const char * name)65 static void InitBeginFuncTest(const char* name)
66 {
67 std::string nameStr(name);
68 }
69
InitEndFuncTest(const char * name)70 static void InitEndFuncTest(const char* name)
71 {
72 std::string nameStr(name);
73 }
74
75 /**
76 * @tc.name: WatchdogInner thread RemoveInnerTask test
77 * @tc.desc: add test case
78 * @tc.type: FUNC
79 */
80 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_TaskRemoveInnerTask_001, TestSize.Level1)
81 {
82 WatchdogInner::GetInstance().RemoveInnerTask("WatchdogInnerTest_RemoveInnerTask_001");
83 ASSERT_EQ(WatchdogInner::GetInstance().checkerQueue_.size(), 0);
84 }
85
86 /**
87 * @tc.name: WatchdogInner thread run a oneshot task
88 * @tc.desc: Verify whether the task has been executed failed
89 * @tc.type: FUNC
90 */
91 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_RunOneShotTask_001, TestSize.Level1)
92 {
93 int taskResult = 0;
__anon4a7f47600102() 94 auto taskFunc = [&taskResult]() { taskResult = 1; };
95 WatchdogInner::GetInstance().RunOneShotTask("", taskFunc, 0);
96 ASSERT_EQ(taskResult, 0);
97 }
98
99 /**
100 * @tc.name: WatchdogInner TriggerTimerCountTask Test
101 * @tc.desc: add teatcase
102 * @tc.type: FUNC
103 */
104 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_TriggerTimerCountTask_001, TestSize.Level1)
105 {
106 std::string name = "WatchdogInnerTest_RunPeriodicalTask_001";
107 WatchdogInner::GetInstance().TriggerTimerCountTask(name, true, "test");
108 ASSERT_EQ(WatchdogInner::GetInstance().checkerQueue_.size(), 0);
109 }
110
111 /**
112 * @tc.name: WatchdogInner thread run a periodical task
113 * @tc.desc: Verify whether the task has been executed failed
114 * @tc.type: FUNC
115 */
116 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_RunPeriodicalTask_001, TestSize.Level1)
117 {
118 int taskResult = 0;
__anon4a7f47600202() 119 auto taskFunc = [&taskResult]() { taskResult = 1; };
120 std::string name = "RunPeriodicalTask_001";
121 WatchdogInner::GetInstance().RunPeriodicalTask(name, taskFunc, 2000, 0);
122 ASSERT_TRUE(WatchdogInner::GetInstance().checkerQueue_.size() > 0);
123 WatchdogInner::GetInstance().TriggerTimerCountTask(name, false, "test");
124 WatchdogInner::GetInstance().TriggerTimerCountTask(name, true, "test");
125 ASSERT_EQ(taskResult, 0);
126 size_t beforeSize = WatchdogInner::GetInstance().taskNameSet_.size();
127 WatchdogInner::GetInstance().RemoveInnerTask(name);
128 size_t afterSize = WatchdogInner::GetInstance().taskNameSet_.size();
129 ASSERT_EQ(beforeSize, (afterSize + 1));
130 WatchdogInner::GetInstance().RunPeriodicalTask("", taskFunc, 2000, 0);
131 WatchdogInner::GetInstance().SetTimerCountTask("", 1, 1);
132 WatchdogInner::GetInstance().RemoveInnerTask("");
133 }
134
135 /**
136 * @tc.name: WatchdogInner fetch next task;
137 * @tc.desc: Verify whether the task acquisition failed
138 * @tc.type: FUNC
139 */
140 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_FetchNextTask_001, TestSize.Level1)
141 {
142 uint64_t now = GetCurrentTickMillseconds();
143 int taskResult = 0;
__anon4a7f47600302() 144 auto taskFunc = [&taskResult]() { taskResult = 1; };
145 const std::string name = "task1";
146 uint64_t delay = 0;
147 uint64_t interval = 0;
148 bool isOneshot = true;
149 WatchdogTask task(name, taskFunc, delay, interval, isOneshot);
150 int id = WatchdogInner::GetInstance().InsertWatchdogTaskLocked(name, WatchdogTask(name, taskFunc,
151 delay, interval, isOneshot));
152 ASSERT_GT(id, 0);
153 WatchdogInner::GetInstance().isNeedStop_.store(true);
154 ASSERT_EQ(WatchdogInner::GetInstance().FetchNextTask(now, task), 60000);
155 WatchdogInner::GetInstance().isNeedStop_.store(false);
156 WatchdogTask task1;
157 ASSERT_EQ(WatchdogInner::GetInstance().FetchNextTask(now, task1), 60000);
158 WatchdogTask task2("", taskFunc, delay, interval, isOneshot);
159 ASSERT_EQ(WatchdogInner::GetInstance().FetchNextTask(now, task1), 60000);
160 }
161
162 /**
163 * @tc.name: WatchdogInner fetch next task;
164 * @tc.desc: Verify whether the task acquisition successfully
165 * @tc.type: FUNC
166 */
167 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_FetchNextTask_002, TestSize.Level1)
168 {
169 uint64_t now = GetCurrentTickMillseconds() + 6500;
170 int taskResult = 0;
__anon4a7f47600402() 171 auto taskFunc = [&taskResult]() { taskResult = 1; };
172 const std::string name = "FetchNextTask_002";
173 uint64_t delay = 0;
174 uint64_t interval = 0;
175 bool isOneshot = true;
176 WatchdogTask task(name, taskFunc, delay, interval, isOneshot);
177 int id = WatchdogInner::GetInstance().InsertWatchdogTaskLocked(name, WatchdogTask(name, taskFunc,
178 delay, interval, isOneshot));
179 ASSERT_GT(id, 0);
180 ASSERT_EQ(WatchdogInner::GetInstance().FetchNextTask(now, task), 0);
181 }
182
183 /**
184 * @tc.name: WatchdogInner is exceedMaxTaskLocked;
185 * @tc.desc: Verify whether checkerQueue_ is over MAX_WATCH_NUM;
186 * @tc.type: FUNC
187 */
188 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_IsExceedMaxTaskLocked_001, TestSize.Level1)
189 {
190 bool ret = WatchdogInner::GetInstance().IsExceedMaxTaskLocked();
191 ASSERT_EQ(ret, false);
192 }
193
194 /**
195 * @tc.name: WatchdogInner FfrtCallback Test;
196 * @tc.desc: add teatcase
197 * @tc.type: FUNC
198 */
199 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_FfrtCallback_001, TestSize.Level1)
200 {
201 uint64_t taskId = 1;
202 const char *taskInfo = "task";
203 uint32_t delayedTaskCount = 0;
204 ASSERT_TRUE(WatchdogInner::GetInstance().taskIdCnt.empty());
205 WatchdogInner::GetInstance().FfrtCallback(taskId, taskInfo, delayedTaskCount);
206 }
207
208 /**
209 * @tc.name: WatchdogInner FfrtCallback Test;
210 * @tc.desc: add teatcase
211 * @tc.type: FUNC
212 */
213 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_FfrtCallback_002, TestSize.Level1)
214 {
215 uint64_t taskId = 1;
216 const char *taskInfo = "Queue_Schedule_Timeout";
217 uint32_t delayedTaskCount = 0;
218 OHOS::system::SetParameter("hiviewdfx.appfreeze.filter_bundle_name", "WatchdogInnerUnitTest");
219 EXPECT_TRUE(IsProcessDebug(getprocpid()));
220 WatchdogInner::GetInstance().FfrtCallback(taskId, taskInfo, delayedTaskCount);
221 }
222
223 /**
224 * @tc.name: WatchdogInner SendMsgToHungtask Test;
225 * @tc.desc: add teatcase
226 * @tc.type: FUNC
227 */
228 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_SendMsgToHungtask_001, TestSize.Level1)
229 {
230 bool ret =WatchdogInner::GetInstance().SendMsgToHungtask(
231 "WatchdogInnerTest_SendMsgToHungtask_001");
232 ASSERT_FALSE(ret);
233 }
234
235 /**
236 * @tc.name: WatchdogInner
237 * @tc.desc: add testcase
238 * @tc.type: FUNC
239 */
240 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_KillProcessTest, TestSize.Level1)
241 {
242 int32_t pid = 12000; // test value
243 bool ret = KillProcessByPid(pid);
244 EXPECT_EQ(ret, false);
245 ret = IsProcessDebug(pid);
246 printf("IsProcessDebug ret=%s", ret ? "true" : "false");
247 std::string path = "/data/test/log/test1.txt";
248 std::ofstream ofs(path, std::ios::trunc);
249 if (!ofs.is_open()) {
250 printf("open path failed!, path=%s\n", path.c_str());
251 FAIL();
252 }
253 ofs << "aync 1:1 to 2:2 code 9 wait:4 s test" << std::endl;
254 ofs << "12000:12000 to 12001:12001 code 9 wait:1 s test" << std::endl;
255 ofs << "22000:22000 to 12001:12001 code 9 wait:1 s test" << std::endl;
256 ofs << "12000:12000 to 12001:12001 code 9 wait:4 s test" << std::endl;
257 ofs.close();
258 std::ifstream fin(path);
259 if (!fin.is_open()) {
260 printf("open path failed!, path=%s\n", path.c_str());
261 FAIL();
262 }
263 int result = ParsePeerBinderPid(fin, pid);
264 fin.close();
265 EXPECT_TRUE(result > 0);
266
267 path = "/data/test/log/test2.txt";
268 ofs.open(path.c_str(), std::ios::trunc);
269 if (!ofs.is_open()) {
270 printf("open path failed!, path=%s\n", path.c_str());
271 FAIL();
272 }
273 ofs << "context" << std::endl;
274 ofs.close();
275 fin.open(path.c_str());
276 if (!fin.is_open()) {
277 printf("open path failed!, path=%s\n", path.c_str());
278 FAIL();
279 }
280 result = ParsePeerBinderPid(fin, pid);
281 fin.close();
282 EXPECT_TRUE(result < 0);
283 }
284
285 /**
286 * @tc.name: WatchdogInner;
287 * @tc.desc: add testcase
288 * @tc.type: FUNC
289 */
290 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_001, TestSize.Level1)
291 {
292 std::string result = GetFormatDate();
293 printf("GetFormatDate:%s\n", result.c_str());
294 EXPECT_TRUE(!result.empty());
295 bool devRet1 = IsDeveloperOpen();
296 bool devRet2 = IsDeveloperOpen();
297 bool betaRet1 = IsBetaVersion();
298 bool betaRet2 = IsBetaVersion();
299 EXPECT_TRUE(devRet1 == devRet2);
300 EXPECT_TRUE(betaRet1 == betaRet2);
301 int64_t ret1 = GetTimeStamp();
302 EXPECT_TRUE(ret1 > 0);
303 std::string stack = "";
304 std::string heaviestStack = "";
305 const char* samplePath = "libthread_sampler.z.so";
306 WatchdogInner::GetInstance().threadSamplerFuncHandler_ = dlopen(samplePath, RTLD_LAZY);
307 EXPECT_TRUE(WatchdogInner::GetInstance().threadSamplerFuncHandler_ != nullptr);
308 WatchdogInner::GetInstance().InitThreadSamplerFuncs();
309 WatchdogInner::GetInstance().CollectStack(stack, heaviestStack);
310 printf("stack:\n%s", stack.c_str());
311 printf("heaviestStack:\n%s", heaviestStack.c_str());
312 WatchdogInner::GetInstance().Deinit();
313 WatchdogInner::GetInstance().ResetThreadSamplerFuncs();
314 }
315
316 /**
317 * @tc.name: WatchdogInner;
318 * @tc.desc: add testcase
319 * @tc.type: FUNC
320 */
321 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_002, TestSize.Level1)
322 {
323 TimePoint endTime = std::chrono::steady_clock::now();
324 int sampleInterval = SAMPLE_DEFULE_INTERVAL;
325 WatchdogInner::GetInstance().StartProfileMainThread(endTime, 150, sampleInterval);
326 int32_t left = 4;
327 int32_t end = time(nullptr) + left;
328 while (left > 0) {
329 left = end - time(nullptr);
330 }
331
332 left = 10;
333 end = time(nullptr) + left;
334 while (left > 0) {
335 left = end - time(nullptr);
336 }
337
338 WatchdogInner::GetInstance().StartProfileMainThread(endTime, 150, sampleInterval);
339 left = 5;
340 end = time(nullptr) + left;
341 while (left > 0) {
342 left = end - time(nullptr);
343 }
344 sleep(4);
345 std::string stack = "";
346 std::string heaviestStack = "";
347 WatchdogInner::GetInstance().CollectStack(stack, heaviestStack);
348 printf("stack:\n%s", stack.c_str());
349 printf("heaviestStack:\n%s", heaviestStack.c_str());
350 WatchdogInner::GetInstance().Deinit();
351 WatchdogInner::GetInstance().ResetThreadSamplerFuncs();
352 EXPECT_TRUE(stack.size() >= heaviestStack.size());
353 }
354
355
356 /**
357 * @tc.name: WatchdogInner;
358 * @tc.desc: add testcase
359 * @tc.type: FUNC
360 */
361 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_003, TestSize.Level1)
362 {
__anon4a7f47600502(const std::string &name, int waitState) 363 auto timeOutCallback = [](const std::string &name, int waitState) {
364 printf("timeOutCallback name is %s, waitState is %d\n", name.c_str(), waitState);
365 };
366 int result = WatchdogInner::GetInstance().AddThread("AddThread", nullptr, timeOutCallback, 10);
367 EXPECT_TRUE(result <= 0);
368 int32_t pid = getprocpid();
369 WatchdogInner::WriteStringToFile(pid, "0");
370 bool ret = WatchdogInner::GetInstance().ReportMainThreadEvent(gettid());
371 printf("ReportMainThreadEvent ret=%s\n", ret ? "true" : "fasle");
372 int32_t interval = 150; // test value
373 WatchdogInner::GetInstance().StartTraceProfile();
374 WatchdogInner::GetInstance().DumpTraceProfile(interval);
375 ret = IsFileNameFormat('1');
376 EXPECT_TRUE(!ret);
377 ret = IsFileNameFormat('b');
378 EXPECT_TRUE(!ret);
379 ret = IsFileNameFormat('B');
380 EXPECT_TRUE(!ret);
381 ret = IsFileNameFormat('_');
382 EXPECT_TRUE(!ret);
383 ret = IsFileNameFormat('*');
384 EXPECT_TRUE(ret);
385 std::string path = "";
386 std::string stack = "STACK";
387 bool isOverLimit = false;
388 ret = WriteStackToFd(getprocpid(), path, stack, "test", isOverLimit);
389 EXPECT_TRUE(ret);
390 }
391
392 /**
393 * @tc.name: WatchdogInner Test
394 * @tc.desc: add testcase
395 * @tc.type: FUNC
396 */
397 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_004, TestSize.Level1)
398 {
399 WatchdogInner::GetInstance().buissnessThreadInfo_.insert(getproctid());
400 EXPECT_TRUE(WatchdogInner::GetInstance().buissnessThreadInfo_.size() > 0);
401 printf("ret=%d\n", WatchdogInner::GetInstance().ReportMainThreadEvent(gettid()));
402 WatchdogInner::GetInstance().StartTraceProfile();
403 WatchdogInner::GetInstance().DumpTraceProfile(150); // test value
404 FunctionOpen(nullptr, "test");
405 }
406
407 /**
408 * @tc.name: WatchdogInner GetFfrtTaskTid test;
409 * @tc.desc: add testcase
410 * @tc.type: FUNC
411 */
412 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_GetFfrtTaskTid_001, TestSize.Level1)
413 {
414 std::string msg = "us. queue name";
415 std::string str = "us. queue name [";
416 auto index = msg.find(str);
417 EXPECT_TRUE(index == std::string::npos);
418 int32_t tid = -1;
419 WatchdogInner::GetInstance().GetFfrtTaskTid(tid, msg);
420 EXPECT_EQ(tid, -1);
421 }
422
423 /**
424 * @tc.name: WatchdogInner GetFfrtTaskTid test;
425 * @tc.desc: add testcase
426 * @tc.type: FUNC
427 */
428 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_GetFfrtTaskTid_002, TestSize.Level1)
429 {
430 std::string msg = "us. queue name []";
431 std::string str = "], remaining tasks count=";
432 auto index = msg.find(str);
433 EXPECT_TRUE(index == std::string::npos);
434 int32_t tid = -1;
435 WatchdogInner::GetInstance().GetFfrtTaskTid(tid, msg);
436 EXPECT_EQ(tid, -1);
437 }
438
439 /**
440 * @tc.name: WatchdogInner GetFfrtTaskTid test;
441 * @tc.desc: add testcase
442 * @tc.type: FUNC
443 */
444 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_GetFfrtTaskTid_003, TestSize.Level1)
445 {
446 std::string msg = "us. queue name [], remaining tasks count=11, worker tid "
447 "12220 is running, task id 12221";
448 std::string str = "], remaining tasks count=";
449 auto index = msg.find(str);
450 EXPECT_TRUE(index != std::string::npos);
451 int32_t tid = -1;
452 WatchdogInner::GetInstance().GetFfrtTaskTid(tid, msg);
453 EXPECT_EQ(tid, -1);
454 }
455
456 /**
457 * @tc.name: WatchdogInner GetFfrtTaskTid test;
458 * @tc.desc: add testcase
459 * @tc.type: FUNC
460 */
461 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_GetFfrtTaskTid_004, TestSize.Level1)
462 {
463 std::string msg = "us. queue name [WatchdogInnerTest_GetFfrtTaskTid_004], "
464 "remaining tasks count=11, worker tid abc\\nWatchdogInnerTest_GetFfrtTaskTid_004 "
465 " is running, task id 12221";
466 std::string str = "], remaining tasks count=";
467 auto index = msg.find(str);
468 EXPECT_TRUE(index != std::string::npos);
469 int32_t tid = -1;
470 WatchdogInner::GetInstance().GetFfrtTaskTid(tid, msg);
471 EXPECT_EQ(tid, -1);
472 }
473
474 /**
475 * @tc.name: WatchdogInner GetProcessNameFromProcCmdline test;
476 * @tc.desc: add testcase
477 * @tc.type: FUNC
478 */
479 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_GetProcNameFromProcCmdline_001, TestSize.Level1)
480 {
481 std::string procName1 = GetProcessNameFromProcCmdline(getpid());
482 std::string procName2 = GetProcessNameFromProcCmdline(25221); // test value
483 EXPECT_TRUE(procName1 != procName2);
484 std::string procName3 = GetProcessNameFromProcCmdline(getpid());
485 EXPECT_TRUE(procName1 == procName3);
486 }
487
488 /**
489 * @tc.name: WatchdogInner SendFfrtEvent test;
490 * @tc.desc: add testcase
491 * @tc.type: FUNC
492 */
493 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_SendFfrtEvent_001, TestSize.Level1)
494 {
495 EXPECT_TRUE(IsProcessDebug(getprocpid()));
496 WatchdogInner::GetInstance().SendFfrtEvent("msg", "testName", "taskInfo");
497 }
498
499 /**
500 * @tc.name: WatchdogInner LeftTimeExitProcess test;
501 * @tc.desc: add testcase
502 * @tc.type: FUNC
503 */
504 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_LeftTimeExitProcess_001, TestSize.Level1)
505 {
506 EXPECT_TRUE(IsProcessDebug(getprocpid()));
507 WatchdogInner::GetInstance().LeftTimeExitProcess("msg");
508 }
509
510 /**
511 * @tc.name: WatchdogInner KillPeerBinderProcess test;
512 * @tc.desc: add testcase
513 * @tc.type: FUNC
514 */
515 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_KillPeerBinderProcess_001, TestSize.Level1)
516 {
517 EXPECT_TRUE(IsProcessDebug(getprocpid()));
518 WatchdogInner::GetInstance().KillPeerBinderProcess("msg");
519 }
520
521 /**
522 * @tc.name: WatchdogInner InitMainLooperWatcher Test
523 * @tc.desc: add testcase
524 * @tc.type: FUNC
525 */
526 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_InitMainLooperWatcher_001, TestSize.Level1)
527 {
528 WatchdogInner::GetInstance().InitMainLooperWatcher(nullptr, nullptr);
529 WatchdogInnerBeginFunc beginTest = InitBeginFuncTest;
530 WatchdogInnerEndFunc endTest = InitEndFuncTest;
531 WatchdogInner::GetInstance().InitMainLooperWatcher(&beginTest, &endTest);
532 int count = 0;
533 while (count < 10) {
534 beginTest("Test");
535 usleep(350 * 1000); // test value
536 endTest("Test");
537 count++;
538 }
539 WatchdogInner::GetInstance().traceContent_.traceState = 0;
540 WatchdogInner::GetInstance().InitMainLooperWatcher(&beginTest, &endTest);
541 beginTest("Test");
542 sleep(2); // test value
543 endTest("Test");
544 WatchdogInner::GetInstance().traceContent_.traceState = 1;
545 beginTest("Test");
546 usleep(3500 * 1000); // test value
547 endTest("Test");
548 EXPECT_TRUE(WatchdogInner::GetInstance().stackContent_.reportTimes < 1);
549 EXPECT_EQ(WatchdogInner::GetInstance().stackContent_.isStartSampleEnabled, true);
550 }
551
552 /**
553 * @tc.name: WatchdogInner InitMainLooperWatcher Test
554 * @tc.desc: add testcase
555 * @tc.type: FUNC
556 */
557 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_InitMainLooperWatcher_002, TestSize.Level1)
558 {
559 WatchdogInner::GetInstance().InitMainLooperWatcher(nullptr, nullptr);
560 WatchdogInnerBeginFunc beginTest = InitBeginFuncTest;
561 WatchdogInnerEndFunc endTest = InitEndFuncTest;
562 WatchdogInner::GetInstance().InitMainLooperWatcher(&beginTest, &endTest);
563 WatchdogInner::GetInstance().SetScrollState(true);
564 int count = 0;
565 while (count < 4) {
566 beginTest("Test");
567 usleep(50 * 1000); // test value
568 endTest("Test");
569 count++;
570 }
571 sleep(2); // test value
572 EXPECT_TRUE(WatchdogInner::GetInstance().stackContent_.scrollTimes < 1);
573 EXPECT_EQ(WatchdogInner::GetInstance().stackContent_.isStartSampleEnabled, true);
574 }
575
576 /**
577 * @tc.name: WatchdogInner SetEventConfig test;
578 * @tc.desc: set log_type failed.
579 * @tc.type: FUNC
580 */
581 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_SetEventConfig_001, TestSize.Level1)
582 {
583 /**
584 * @tc.name: WatchdogInner SetEventConfig test;
585 * @tc.desc: set paramsMap is null.
586 * @tc.type: FUNC
587 */
588 std::map<std::string, std::string> paramsMap;
589 int ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
590 EXPECT_EQ(ret, -1);
591 /**
592 * @tc.name: WatchdogInner SetEventConfig test;
593 * @tc.desc: set log_type is not a number.
594 * @tc.type: FUNC
595 */
596 paramsMap[KEY_LOG_TYPE] = "";
597 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
598 EXPECT_EQ(ret, -1);
599 paramsMap[KEY_LOG_TYPE] = "ab0";
600 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
601 EXPECT_EQ(ret, -1);
602 /**
603 * @tc.name: WatchdogInner SetEventConfig test;
604 * @tc.desc: set log_type is negative number.
605 * @tc.type: FUNC
606 */
607 paramsMap[KEY_LOG_TYPE] = "-1";
608 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
609 EXPECT_EQ(ret, -1);
610 /**
611 * @tc.name: WatchdogInner SetEventConfig test;
612 * @tc.desc: set log_type success.
613 * @tc.type: FUNC
614 */
615 paramsMap[KEY_LOG_TYPE] = "0";
616 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
617 EXPECT_EQ(ret, 0);
618 /**
619 * @tc.name: WatchdogInner SetEventConfig test;
620 * @tc.desc: set log_type failed.
621 * @tc.type: FUNC
622 */
623 paramsMap[KEY_LOG_TYPE] = "1";
624 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
625 EXPECT_EQ(ret, -1);
626
627 /**
628 * @tc.name: WatchdogInner SetEventConfig test;
629 * @tc.desc: set log_type failed.
630 * @tc.type: FUNC
631 */
632 paramsMap[KEY_LOG_TYPE] = "2";
633 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
634 EXPECT_EQ(ret, 0);
635
636 /**
637 * @tc.name: WatchdogInner SetEventConfig test;
638 * @tc.desc: set log_type out of range.
639 * @tc.type: FUNC
640 */
641 paramsMap[KEY_LOG_TYPE] = "100";
642 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
643 EXPECT_EQ(ret, -1);
644 }
645
646 /**
647 * @tc.name: WatchdogInner SetEventConfig test;
648 * @tc.desc: set log_type is 1.
649 * @tc.type: FUNC
650 */
651 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_SetEventConfig_002, TestSize.Level1)
652 {
653 WatchdogInner::GetInstance().InitMainLooperWatcher(nullptr, nullptr);
654 WatchdogInnerBeginFunc beginTest = InitBeginFuncTest;
655 WatchdogInnerEndFunc endTest = InitEndFuncTest;
656 WatchdogInner::GetInstance().InitMainLooperWatcher(&beginTest, &endTest);
657
658 std::map<std::string, std::string> paramsMap;
659 paramsMap[KEY_LOG_TYPE] = "1";
660 paramsMap[KEY_SAMPLE_INTERVAL] = "100";
661 paramsMap[KEY_IGNORE_STARTUP_TIME] = "12";
662 paramsMap[KEY_SAMPLE_COUNT] = "21";
663 paramsMap[KEY_SAMPLE_REPORT_TIMES] = "3";
664 int ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
665 EXPECT_EQ(ret, 0);
666 beginTest("Test");
667 sleep(12); // test value
668 int count = 0;
669 while (count < 3) {
670 beginTest("Test");
671 usleep(140 * 1000); // test value
672 endTest("Test");
673 count++;
674 }
675 sleep(5);
676 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_LOG_TYPE], 1);
677 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_SAMPLE_INTERVAL], 100);
678 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_IGNORE_STARTUP_TIME], 12);
679 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_SAMPLE_COUNT], 21);
680 EXPECT_TRUE(WatchdogInner::GetInstance().stackContent_.reportTimes < 3);
681 printf("stackContent_.reportTimes: %d", WatchdogInner::GetInstance().stackContent_.reportTimes);
682 }
683
684 /**
685 * @tc.name: WatchdogInner SetEventConfig test;
686 * @tc.desc: set log_type is 0.
687 * @tc.type: FUNC
688 */
689 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_SetEventConfig_003, TestSize.Level1)
690 {
691 WatchdogInner::GetInstance().InitMainLooperWatcher(nullptr, nullptr);
692 WatchdogInnerBeginFunc beginTest = InitBeginFuncTest;
693 WatchdogInnerEndFunc endTest = InitEndFuncTest;
694 WatchdogInner::GetInstance().InitMainLooperWatcher(&beginTest, &endTest);
695
696 std::map<std::string, std::string> paramsMap;
697 paramsMap[KEY_LOG_TYPE] = "0";
698 int ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
699 EXPECT_EQ(ret, 0);
700 beginTest("Test");
701 sleep(11); // test value
702 int count = 0;
703 while (count < 2) {
704 beginTest("Test");
705 usleep(200 * 1000); // test value
706 endTest("Test");
707 count++;
708 }
709 sleep(5);
710 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_LOG_TYPE], 0);
711 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_SAMPLE_INTERVAL], SAMPLE_DEFULE_INTERVAL);
712 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_IGNORE_STARTUP_TIME], DEFAULT_IGNORE_STARTUP_TIME);
713 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_SAMPLE_COUNT], SAMPLE_DEFULE_COUNT);
714 printf("stackContent_.reportTimes: %d", WatchdogInner::GetInstance().stackContent_.reportTimes);
715 }
716
717 /**
718 * @tc.name: WatchdogInner SetEventConfig test;
719 * @tc.desc: set log_type is 2.
720 * @tc.type: FUNC
721 */
722 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_SetEventConfig_004, TestSize.Level1)
723 {
724 WatchdogInner::GetInstance().InitMainLooperWatcher(nullptr, nullptr);
725 WatchdogInnerBeginFunc beginTest = InitBeginFuncTest;
726 WatchdogInnerEndFunc endTest = InitEndFuncTest;
727 WatchdogInner::GetInstance().InitMainLooperWatcher(&beginTest, &endTest);
728
729 std::map<std::string, std::string> paramsMap;
730 paramsMap[KEY_LOG_TYPE] = "2";
731 int ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
732 EXPECT_EQ(ret, 0);
733 beginTest("Test");
734 usleep(2000 * 1000); // test value
735 endTest("Test");
736 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_LOG_TYPE], 2);
737 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_SAMPLE_INTERVAL], SAMPLE_DEFULE_INTERVAL);
738 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_IGNORE_STARTUP_TIME], DEFAULT_IGNORE_STARTUP_TIME);
739 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_SAMPLE_COUNT], SAMPLE_DEFULE_COUNT);
740 }
741
742 /**
743 * @tc.name: WatchdogInner SetEventConfig test;
744 * @tc.desc: set KEY_LOG_TYPE is 1, other parameters out of range.
745 * @tc.type: FUNC
746 */
747 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_SetEventConfig_005, TestSize.Level1)
748 {
749 std::map<std::string, std::string> paramsMap;
750 /**
751 * @tc.desc: set sample interval out of range.
752 */
753 paramsMap[KEY_LOG_TYPE] = "1";
754 paramsMap[KEY_SAMPLE_INTERVAL] = "49";
755 paramsMap[KEY_IGNORE_STARTUP_TIME] = "15";
756 paramsMap[KEY_SAMPLE_COUNT] = "21";
757 paramsMap[KEY_SAMPLE_REPORT_TIMES] = "3";
758 int ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
759 EXPECT_EQ(ret, -1);
760 /**
761 * @tc.desc: set ignore startup time out of range.
762 */
763 paramsMap[KEY_SAMPLE_INTERVAL] = "50";
764 paramsMap[KEY_IGNORE_STARTUP_TIME] = "1";
765 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
766 EXPECT_EQ(ret, -1);
767 /**
768 * @tc.desc: set sample count out of range.
769 */
770 paramsMap[KEY_IGNORE_STARTUP_TIME] = "10";
771 paramsMap[KEY_SAMPLE_COUNT] = "1000";
772 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
773 EXPECT_EQ(ret, -1);
774 /**
775 * @tc.desc: set report times out of range.
776 */
777 paramsMap[KEY_SAMPLE_COUNT] = "10";
778 paramsMap[KEY_SAMPLE_REPORT_TIMES] = "5";
779 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
780 EXPECT_EQ(ret, -1);
781 }
782
783 /**
784 * @tc.name: WatchdogInner SetEventConfig test;
785 * @tc.desc: set param is invalid.
786 * @tc.type: FUNC
787 */
788 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_SetEventConfig_006, TestSize.Level1)
789 {
790 std::map<std::string, std::string> paramsMap;
791 /**
792 * @tc.desc: set paramsMap's key is invalid.
793 */
794 paramsMap["ABC"] = "abc";
795 int ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
796 EXPECT_EQ(ret, -1);
797 /**
798 * @tc.desc: set paramMap size out of range.
799 */
800 paramsMap[KEY_LOG_TYPE] = "0";
801 paramsMap[KEY_SAMPLE_INTERVAL] = "49";
802 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
803 EXPECT_EQ(ret, -1);
804 /**
805 * @tc.desc: set report times is not a number.
806 */
807 paramsMap[KEY_LOG_TYPE] = "1";
808 paramsMap[KEY_SAMPLE_INTERVAL] = "50";
809 paramsMap[KEY_IGNORE_STARTUP_TIME] = "15";
810 paramsMap[KEY_SAMPLE_COUNT] = "21";
811 paramsMap[KEY_SAMPLE_REPORT_TIMES] = "abc";
812 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
813 EXPECT_EQ(ret, -1);
814 /**
815 * @tc.desc: set sample count is not a number.
816 */
817 paramsMap[KEY_SAMPLE_COUNT] = "abc";
818 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
819 EXPECT_EQ(ret, -1);
820 /**
821 * @tc.desc: set ignore startup time out of range.
822 */
823 paramsMap[KEY_IGNORE_STARTUP_TIME] = "abc";
824 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
825 EXPECT_EQ(ret, -1);
826 /**
827 * @tc.desc: set sample interval out of range.
828 */
829 paramsMap[KEY_SAMPLE_INTERVAL] = "abc";
830 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
831 EXPECT_EQ(ret, -1);
832 }
833
834 /**
835 * @tc.name: WatchdogInner GetLimitedSizeName test;
836 * @tc.desc: add testcase
837 * @tc.type: FUNC
838 */
839 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_GetLimitedSizeName_001, TestSize.Level1)
840 {
841 std::string testStr = "WatchdogInnerTest_GetLimitedSizeName_001";
842 std::string name = testStr;
843 int limitValue = 128; // name limit value
844 while (name.size() <= limitValue) {
845 name += testStr;
846 }
847 EXPECT_TRUE(GetLimitedSizeName(name).size() <= limitValue);
848 }
849
850 /**
851 * @tc.name: WatchdogInner IsInSleep test;
852 * @tc.desc: add testcase
853 * @tc.type: FUNC
854 */
855 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_IsInSleep_001, TestSize.Level1)
856 {
857 const std::string name = "WatchdogInnerTest_IsInSleep_001";
858 bool taskResult = 0;
__anon4a7f47600602(void *) 859 XCollieCallback callbackFunc = [&taskResult](void *) {
860 taskResult = 1;
861 };
862
863 WatchdogTask task(name, 0, callbackFunc, nullptr, XCOLLIE_FLAG_DEFAULT);
864 bool ret = WatchdogInner::GetInstance().IsInSleep(task);
865 EXPECT_TRUE(!ret);
866
867 task.bootTimeStart = 0;
868 task.monoTimeStart = 0;
869 ret = WatchdogInner::GetInstance().IsInSleep(task);
870 EXPECT_TRUE(!ret);
871
872 uint64_t bootTimeStart = 0;
873 uint64_t monoTimeStart = 0;
874 CalculateTimes(bootTimeStart, monoTimeStart);
875 uint64_t testValue = 2100;
876 task.bootTimeStart = bootTimeStart;
877 task.monoTimeStart = monoTimeStart + testValue;
878 ret = WatchdogInner::GetInstance().IsInSleep(task);
879 EXPECT_TRUE(ret);
880 }
881
882 /**
883 * @tc.name: WatchdogInner GetAppStartTime test;
884 * @tc.desc: add testcase
885 * @tc.type: FUNC
886 */
887 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_GetAppStartTime_001, TestSize.Level1)
888 {
889 std::string testStr = "WatchdogInnerTest_GetAppStartTime_001";
890 int64_t time = GetAppStartTime(-1, 0);
891 EXPECT_TRUE(time != 0);
892 }
893
894 /**
895 * @tc.name: WatchdogInner SetSpecifiedProcessName test;
896 * @tc.desc: add testcase
897 * @tc.type: FUNC
898 */
899 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_SetSpecifiedProcessName_001, TestSize.Level1)
900 {
901 std::string testStr = "WatchdogInnerTest_SetSpecifiedProcessName_001";
902 WatchdogInner::GetInstance().SetSpecifiedProcessName(testStr);
903 EXPECT_EQ(WatchdogInner::GetInstance().GetSpecifiedProcessName(), testStr);
904 }
905
906 /**
907 * @tc.name: WatchdogInner SetScrollState test;
908 * @tc.desc: add testcase
909 * @tc.type: FUNC
910 */
911 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_SetScrollState_001, TestSize.Level1)
912 {
913 WatchdogInner::GetInstance().SetScrollState(true);
914 EXPECT_EQ(WatchdogInner::GetInstance().isScroll_, true);
915 }
916 } // namespace HiviewDFX
917 } // namespace OHOS
918