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 "watchdog_inner_test.h"
26
27 #define private public
28 #define protected public
29 #include "watchdog_inner.h"
30 #undef private
31 #undef protected
32
33 #include "xcollie_utils.h"
34 #include "directory_ex.h"
35 #include "file_ex.h"
36 #include "event_handler.h"
37 #include "ffrt_inner.h"
38
39 using namespace testing::ext;
40 using namespace OHOS::AppExecFwk;
41 namespace OHOS {
42 namespace HiviewDFX {
SetUpTestCase(void)43 void WatchdogInnerTest::SetUpTestCase(void)
44 {
45 }
46
TearDownTestCase(void)47 void WatchdogInnerTest::TearDownTestCase(void)
48 {
49 }
50
SetUp(void)51 void WatchdogInnerTest::SetUp(void)
52 {
53 }
54
TearDown(void)55 void WatchdogInnerTest::TearDown(void)
56 {
57 }
58
InitSeLinuxEnabled()59 void InitSeLinuxEnabled()
60 {
61 bool isSelinuxEnabled = false;
62 constexpr uint32_t BUF_SIZE_64 = 64;
63 char buffer[BUF_SIZE_64] = {'\0'};
64 FILE* fp = popen("getenforce", "r");
65 if (fp != nullptr) {
66 fgets(buffer, sizeof(buffer), fp);
67 std::string str = buffer;
68 printf("buffer is %s\n", str.c_str());
69 if (str.find("Enforcing") != str.npos) {
70 printf("Enforcing %s\n", str.c_str());
71 isSelinuxEnabled = true;
72 } else {
73 printf("This isn't Enforcing %s\n", str.c_str());
74 }
75 pclose(fp);
76 } else {
77 printf("fp == nullptr\n");
78 }
79 system("setenforce 0");
80
81 constexpr mode_t defaultLogDirMode = 0770;
82 std::string path = "/data/test/log";
83 if (!OHOS::FileExists(path)) {
84 OHOS::ForceCreateDirectory(path);
85 OHOS::ChangeModeDirectory(path, defaultLogDirMode);
86 }
87 }
88
InitBeginFuncTest(const char * name)89 static void InitBeginFuncTest(const char* name)
90 {
91 std::string nameStr(name);
92 }
93
InitEndFuncTest(const char * name)94 static void InitEndFuncTest(const char* name)
95 {
96 std::string nameStr(name);
97 }
98
99 /**
100 * @tc.name: WatchdogInner thread run a oneshot task
101 * @tc.desc: Verify whether the task has been executed failed
102 * @tc.type: FUNC
103 */
104 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_RunOneShotTask_001, TestSize.Level1)
105 {
106 int taskResult = 0;
__anon3a466ae20102() 107 auto taskFunc = [&taskResult]() { taskResult = 1; };
108 WatchdogInner::GetInstance().RunOneShotTask("", taskFunc, 0);
109 ASSERT_EQ(taskResult, 0);
110 }
111
112 /**
113 * @tc.name: WatchdogInner TriggerTimerCountTask Test
114 * @tc.desc: add teatcase
115 * @tc.type: FUNC
116 */
117 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_TriggerTimerCountTask_001, TestSize.Level1)
118 {
119 std::string name = "WatchdogInnerTest_RunPeriodicalTask_001";
120 WatchdogInner::GetInstance().TriggerTimerCountTask(name, true, "test");
121 ASSERT_EQ(WatchdogInner::GetInstance().checkerQueue_.size(), 0);
122 }
123
124 /**
125 * @tc.name: WatchdogInner thread run a periodical task
126 * @tc.desc: Verify whether the task has been executed failed
127 * @tc.type: FUNC
128 */
129 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_RunPeriodicalTask_001, TestSize.Level1)
130 {
131 int taskResult = 0;
__anon3a466ae20202() 132 auto taskFunc = [&taskResult]() { taskResult = 1; };
133 std::string name = "RunPeriodicalTask_001";
134 WatchdogInner::GetInstance().RunPeriodicalTask(name, taskFunc, 2000, 0);
135 ASSERT_TRUE(WatchdogInner::GetInstance().checkerQueue_.size() > 0);
136 WatchdogInner::GetInstance().TriggerTimerCountTask(name, false, "test");
137 WatchdogInner::GetInstance().TriggerTimerCountTask(name, true, "test");
138 ASSERT_EQ(taskResult, 0);
139 size_t beforeSize = WatchdogInner::GetInstance().taskNameSet_.size();
140 WatchdogInner::GetInstance().RemoveInnerTask(name);
141 size_t afterSize = WatchdogInner::GetInstance().taskNameSet_.size();
142 ASSERT_EQ(beforeSize, (afterSize + 1));
143 WatchdogInner::GetInstance().RunPeriodicalTask("", taskFunc, 2000, 0);
144 WatchdogInner::GetInstance().SetTimerCountTask("", 1, 1);
145 WatchdogInner::GetInstance().RemoveInnerTask("");
146 }
147
148 /**
149 * @tc.name: WatchdogInner fetch next task;
150 * @tc.desc: Verify whether the task acquisition failed
151 * @tc.type: FUNC
152 */
153 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_FetchNextTask_001, TestSize.Level1)
154 {
155 uint64_t now = GetCurrentTickMillseconds();
156 int taskResult = 0;
__anon3a466ae20302() 157 auto taskFunc = [&taskResult]() { taskResult = 1; };
158 const std::string name = "task1";
159 uint64_t delay = 0;
160 uint64_t interval = 0;
161 bool isOneshot = true;
162 WatchdogTask task(name, taskFunc, delay, interval, isOneshot);
163 int id = WatchdogInner::GetInstance().InsertWatchdogTaskLocked(name, WatchdogTask(name, taskFunc,
164 delay, interval, isOneshot));
165 ASSERT_GT(id, 0);
166 WatchdogInner::GetInstance().isNeedStop_.store(true);
167 ASSERT_EQ(WatchdogInner::GetInstance().FetchNextTask(now, task), 60000);
168 WatchdogInner::GetInstance().isNeedStop_.store(false);
169 WatchdogTask task1;
170 ASSERT_EQ(WatchdogInner::GetInstance().FetchNextTask(now, task1), 60000);
171 }
172
173 /**
174 * @tc.name: WatchdogInner fetch next task;
175 * @tc.desc: Verify whether the task acquisition successfully
176 * @tc.type: FUNC
177 */
178 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_FetchNextTask_002, TestSize.Level1)
179 {
180 uint64_t now = GetCurrentTickMillseconds() + 6500;
181 int taskResult = 0;
__anon3a466ae20402() 182 auto taskFunc = [&taskResult]() { taskResult = 1; };
183 const std::string name = "FetchNextTask_002";
184 uint64_t delay = 0;
185 uint64_t interval = 0;
186 bool isOneshot = true;
187 WatchdogTask task(name, taskFunc, delay, interval, isOneshot);
188 int id = WatchdogInner::GetInstance().InsertWatchdogTaskLocked(name, WatchdogTask(name, taskFunc,
189 delay, interval, isOneshot));
190 ASSERT_GT(id, 0);
191 ASSERT_EQ(WatchdogInner::GetInstance().FetchNextTask(now, task), 0);
192 }
193
194 /**
195 * @tc.name: WatchdogInner is exceedMaxTaskLocked;
196 * @tc.desc: Verify whether checkerQueue_ is over MAX_WATCH_NUM;
197 * @tc.type: FUNC
198 */
199 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_IsExceedMaxTaskLocked_001, TestSize.Level1)
200 {
201 bool ret = WatchdogInner::GetInstance().IsExceedMaxTaskLocked();
202 ASSERT_EQ(ret, false);
203 }
204
205 /**
206 * @tc.name: WatchdogInner FfrtCallback Test;
207 * @tc.desc: add teatcase
208 * @tc.type: FUNC
209 */
210 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_FfrtCallback_001, TestSize.Level1)
211 {
212 uint64_t taskId = 1;
213 const char *taskInfo = "task";
214 uint32_t delayedTaskCount = 0;
215 ASSERT_TRUE(WatchdogInner::GetInstance().taskIdCnt.empty());
216 WatchdogInner::GetInstance().FfrtCallback(taskId, taskInfo, delayedTaskCount);
217 }
218
219 /**
220 * @tc.name: WatchdogInner SendMsgToHungtask Test;
221 * @tc.desc: add teatcase
222 * @tc.type: FUNC
223 */
224 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_SendMsgToHungtask_001, TestSize.Level1)
225 {
226 bool ret =WatchdogInner::GetInstance().SendMsgToHungtask(
227 "WatchdogInnerTest_SendMsgToHungtask_001");
228 ASSERT_FALSE(ret);
229 }
230
231 /**
232 * @tc.name: WatchdogInner
233 * @tc.desc: add testcase
234 * @tc.type: FUNC
235 */
236 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_KillProcessTest, TestSize.Level1)
237 {
238 int32_t pid = 12000; // test value
239 bool ret = KillProcessByPid(pid);
240 EXPECT_EQ(ret, false);
241 ret = IsProcessDebug(pid);
242 printf("IsProcessDebug ret=%s", ret ? "true" : "false");
243 InitSeLinuxEnabled();
244 std::string path = "/data/test/log/test1.txt";
245 std::ofstream ofs(path, std::ios::trunc);
246 if (!ofs.is_open()) {
247 printf("open path failed!, path=%s\n", path.c_str());
248 FAIL();
249 }
250 ofs << "aync 1:1 to 2:2 code 9 wait:4 s test" << std::endl;
251 ofs << "12000:12000 to 12001:12001 code 9 wait:1 s test" << std::endl;
252 ofs << "22000:22000 to 12001:12001 code 9 wait:1 s test" << std::endl;
253 ofs << "12000:12000 to 12001:12001 code 9 wait:4 s test" << std::endl;
254 ofs.close();
255
256 std::ifstream fin(path);
257 if (!fin.is_open()) {
258 printf("open path failed!, path=%s\n", path.c_str());
259 FAIL();
260 }
261 int result = ParsePeerBinderPid(fin, pid);
262 fin.close();
263 EXPECT_TRUE(result > 0);
264
265 path = "/data/test/log/test2.txt";
266 ofs.open(path.c_str(), std::ios::trunc);
267 if (!ofs.is_open()) {
268 printf("open path failed!, path=%s\n", path.c_str());
269 FAIL();
270 }
271 ofs << "context" << std::endl;
272 ofs.close();
273 fin.open(path.c_str());
274 if (!fin.is_open()) {
275 printf("open path failed!, path=%s\n", path.c_str());
276 FAIL();
277 }
278 result = ParsePeerBinderPid(fin, pid);
279 fin.close();
280 EXPECT_TRUE(result < 0);
281 }
282
283 /**
284 * @tc.name: WatchdogInner;
285 * @tc.desc: add testcase
286 * @tc.type: FUNC
287 */
288 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_001, TestSize.Level1)
289 {
290 std::string result = GetFormatDate();
291 printf("GetFormatDate:%s\n", result.c_str());
292 EXPECT_TRUE(!result.empty());
293 bool devRet1 = IsDeveloperOpen();
294 bool devRet2 = IsDeveloperOpen();
295 bool betaRet1 = IsBetaVersion();
296 bool betaRet2 = IsBetaVersion();
297 EXPECT_TRUE(devRet1 == devRet2);
298 EXPECT_TRUE(betaRet1 == betaRet2);
299 int64_t ret1 = GetTimeStamp();
300 EXPECT_TRUE(ret1 > 0);
301 std::string stack = "";
302 std::string heaviestStack = "";
303 const char* samplePath = "libthread_sampler.z.so";
304 WatchdogInner::GetInstance().threadSamplerFuncHandler_ = dlopen(samplePath, RTLD_LAZY);
305 EXPECT_TRUE(WatchdogInner::GetInstance().threadSamplerFuncHandler_ != nullptr);
306 WatchdogInner::GetInstance().InitThreadSamplerFuncs();
307 WatchdogInner::GetInstance().CollectStack(stack, heaviestStack);
308 printf("stack:\n%s", stack.c_str());
309 printf("heaviestStack:\n%s", heaviestStack.c_str());
310 WatchdogInner::GetInstance().Deinit();
311 WatchdogInner::GetInstance().ResetThreadSamplerFuncs();
312 }
313
314 /**
315 * @tc.name: WatchdogInner;
316 * @tc.desc: add testcase
317 * @tc.type: FUNC
318 */
319 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_002, TestSize.Level1)
320 {
321 int testValue = 150; // test value
322
323 int32_t ret = WatchdogInner::GetInstance().StartProfileMainThread(testValue);
324 int32_t left = 4;
325 int32_t end = time(nullptr) + left;
326 while (left > 0) {
327 left = end - time(nullptr);
328 }
329 printf("ret:%d\n", ret);
330
331 left = 10;
332 end = time(nullptr) + left;
333 while (left > 0) {
334 left = end - time(nullptr);
335 }
336
337 ret = WatchdogInner::GetInstance().StartProfileMainThread(testValue);
338 left = 5;
339 end = time(nullptr) + left;
340 while (left > 0) {
341 left = end - time(nullptr);
342 }
343 sleep(4);
344 EXPECT_EQ(ret, 0);
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 }
353
354 /**
355 * @tc.name: WatchdogInner;
356 * @tc.desc: add testcase
357 * @tc.type: FUNC
358 */
359 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_003, TestSize.Level1)
360 {
__anon3a466ae20502(const std::string &name, int waitState) 361 auto timeOutCallback = [](const std::string &name, int waitState) {
362 printf("timeOutCallback name is %s, waitState is %d\n", name.c_str(), waitState);
363 };
364 int result = WatchdogInner::GetInstance().AddThread("AddThread", nullptr, timeOutCallback, 10);
365 EXPECT_TRUE(result <= 0);
366 int32_t pid = getprocpid();
367 WatchdogInner::WriteStringToFile(pid, "0");
368 bool ret = WatchdogInner::GetInstance().ReportMainThreadEvent(gettid());
369 printf("ReportMainThreadEvent ret=%s\n", ret ? "true" : "fasle");
370 printf("ReportMainThreadEvent ret=%s\n", ret ? "true" : "fasle");
371 int32_t interval = 150; // test value
372 WatchdogInner::GetInstance().StartTraceProfile();
373 WatchdogInner::GetInstance().DumpTraceProfile(interval);
374 ret = IsFileNameFormat('1');
375 EXPECT_TRUE(!ret);
376 ret = IsFileNameFormat('b');
377 EXPECT_TRUE(!ret);
378 ret = IsFileNameFormat('B');
379 EXPECT_TRUE(!ret);
380 ret = IsFileNameFormat('_');
381 EXPECT_TRUE(!ret);
382 ret = IsFileNameFormat('*');
383 EXPECT_TRUE(ret);
384 std::string path = "";
385 std::string stack = "STACK";
386 ret = WriteStackToFd(getprocpid(), path, stack, "test");
387 EXPECT_TRUE(ret);
388 }
389
390 /**
391 * @tc.name: WatchdogInner Test
392 * @tc.desc: add testcase
393 * @tc.type: FUNC
394 */
395 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_004, TestSize.Level1)
396 {
397 WatchdogInner::GetInstance().buissnessThreadInfo_.insert(getproctid());
398 EXPECT_TRUE(WatchdogInner::GetInstance().buissnessThreadInfo_.size() > 0);
399 printf("ret=%d\n", WatchdogInner::GetInstance().ReportMainThreadEvent(gettid()));
400 WatchdogInner::GetInstance().StartTraceProfile();
401 WatchdogInner::GetInstance().DumpTraceProfile(150); // test value
402 FunctionOpen(nullptr, "test");
403 }
404
405 /**
406 * @tc.name: WatchdogInner GetProcessNameFromProcCmdline test;
407 * @tc.desc: add testcase
408 * @tc.type: FUNC
409 */
410 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_GetProcNameFromProcCmdline_001, TestSize.Level1)
411 {
412 std::string procName1 = GetProcessNameFromProcCmdline(getpid());
413 std::string procName2 = GetProcessNameFromProcCmdline(25221); // test value
414 EXPECT_TRUE(procName1 != procName2);
415 std::string procName3 = GetProcessNameFromProcCmdline(getpid());
416 EXPECT_TRUE(procName1 == procName3);
417 }
418
419 /**
420 * @tc.name: WatchdogInner InitMainLooperWatcher Test
421 * @tc.desc: add testcase
422 * @tc.type: FUNC
423 */
424 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_InitMainLooperWatcher_001, TestSize.Level1)
425 {
426 WatchdogInner::GetInstance().InitMainLooperWatcher(nullptr, nullptr);
427 WatchdogInnerBeginFunc beginTest = InitBeginFuncTest;
428 WatchdogInnerEndFunc endTest = InitEndFuncTest;
429 WatchdogInner::GetInstance().InitMainLooperWatcher(&beginTest, &endTest);
430 int count = 0;
431 while (count < 10) {
432 beginTest("Test");
433 usleep(350 * 1000); // test value
434 endTest("Test");
435 count++;
436 }
437 sleep(10); // test value
438 WatchdogInner::GetInstance().traceContent_.traceState = 0;
439 WatchdogInner::GetInstance().InitMainLooperWatcher(&beginTest, &endTest);
440 beginTest("Test");
441 sleep(2); // test value
442 endTest("Test");
443 WatchdogInner::GetInstance().traceContent_.traceState = 1;
444 beginTest("Test");
445 usleep(3500 * 1000); // test value
446 endTest("Test");
447 EXPECT_TRUE(WatchdogInner::GetInstance().stackContent_.reportTimes < 1);
448 EXPECT_EQ(WatchdogInner::GetInstance().stackContent_.isStartSampleEnabled, true);
449 }
450
451 /**
452 * @tc.name: WatchdogInner SetEventConfig test;
453 * @tc.desc: set log_type failed.
454 * @tc.type: FUNC
455 */
456 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_SetEventConfig_001, TestSize.Level1)
457 {
458 /**
459 * @tc.name: WatchdogInner SetEventConfig test;
460 * @tc.desc: set paramsMap is null.
461 * @tc.type: FUNC
462 */
463 std::map<std::string, std::string> paramsMap;
464 int ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
465 EXPECT_EQ(ret, -1);
466 /**
467 * @tc.name: WatchdogInner SetEventConfig test;
468 * @tc.desc: set log_type is not a number.
469 * @tc.type: FUNC
470 */
471 paramsMap[KEY_LOG_TYPE] = "";
472 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
473 EXPECT_EQ(ret, -1);
474 paramsMap[KEY_LOG_TYPE] = "ab0";
475 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
476 EXPECT_EQ(ret, -1);
477 /**
478 * @tc.name: WatchdogInner SetEventConfig test;
479 * @tc.desc: set log_type is negative number.
480 * @tc.type: FUNC
481 */
482 paramsMap[KEY_LOG_TYPE] = "-1";
483 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
484 EXPECT_EQ(ret, -1);
485 /**
486 * @tc.name: WatchdogInner SetEventConfig test;
487 * @tc.desc: set log_type success.
488 * @tc.type: FUNC
489 */
490 paramsMap[KEY_LOG_TYPE] = "0";
491 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
492 EXPECT_EQ(ret, 0);
493 /**
494 * @tc.name: WatchdogInner SetEventConfig test;
495 * @tc.desc: set log_type failed.
496 * @tc.type: FUNC
497 */
498 paramsMap[KEY_LOG_TYPE] = "1";
499 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
500 EXPECT_EQ(ret, -1);
501
502 /**
503 * @tc.name: WatchdogInner SetEventConfig test;
504 * @tc.desc: set log_type failed.
505 * @tc.type: FUNC
506 */
507 paramsMap[KEY_LOG_TYPE] = "2";
508 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
509 EXPECT_EQ(ret, 0);
510
511 /**
512 * @tc.name: WatchdogInner SetEventConfig test;
513 * @tc.desc: set log_type out of range.
514 * @tc.type: FUNC
515 */
516 paramsMap[KEY_LOG_TYPE] = "100";
517 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
518 EXPECT_EQ(ret, -1);
519 }
520
521 /**
522 * @tc.name: WatchdogInner SetEventConfig test;
523 * @tc.desc: set log_type is 1.
524 * @tc.type: FUNC
525 */
526 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_SetEventConfig_002, TestSize.Level1)
527 {
528 WatchdogInner::GetInstance().InitMainLooperWatcher(nullptr, nullptr);
529 WatchdogInnerBeginFunc beginTest = InitBeginFuncTest;
530 WatchdogInnerEndFunc endTest = InitEndFuncTest;
531 WatchdogInner::GetInstance().InitMainLooperWatcher(&beginTest, &endTest);
532
533 std::map<std::string, std::string> paramsMap;
534 paramsMap[KEY_LOG_TYPE] = "1";
535 paramsMap[KEY_SAMPLE_INTERVAL] = "100";
536 paramsMap[KEY_IGNORE_STARTUP_TIME] = "12";
537 paramsMap[KEY_SAMPLE_COUNT] = "21";
538 paramsMap[KEY_SAMPLE_REPORT_TIMES] = "3";
539 int ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
540 EXPECT_EQ(ret, 0);
541 beginTest("Test");
542 sleep(12); // test value
543 int count = 0;
544 while (count < 3) {
545 beginTest("Test");
546 usleep(140 * 1000); // test value
547 endTest("Test");
548 count++;
549 }
550 sleep(5);
551 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_LOG_TYPE], 1);
552 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_SAMPLE_INTERVAL], 100);
553 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_IGNORE_STARTUP_TIME], 12);
554 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_SAMPLE_COUNT], 21);
555 EXPECT_TRUE(WatchdogInner::GetInstance().stackContent_.reportTimes < 3);
556 printf("stackContent_.reportTimes: %d", WatchdogInner::GetInstance().stackContent_.reportTimes);
557 }
558
559 /**
560 * @tc.name: WatchdogInner SetEventConfig test;
561 * @tc.desc: set log_type is 0.
562 * @tc.type: FUNC
563 */
564 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_SetEventConfig_003, TestSize.Level1)
565 {
566 WatchdogInner::GetInstance().InitMainLooperWatcher(nullptr, nullptr);
567 WatchdogInnerBeginFunc beginTest = InitBeginFuncTest;
568 WatchdogInnerEndFunc endTest = InitEndFuncTest;
569 WatchdogInner::GetInstance().InitMainLooperWatcher(&beginTest, &endTest);
570
571 std::map<std::string, std::string> paramsMap;
572 paramsMap[KEY_LOG_TYPE] = "0";
573 int ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
574 EXPECT_EQ(ret, 0);
575 beginTest("Test");
576 sleep(11); // test value
577 int count = 0;
578 while (count < 2) {
579 beginTest("Test");
580 usleep(200 * 1000); // test value
581 endTest("Test");
582 count++;
583 }
584 sleep(5);
585 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_LOG_TYPE], 0);
586 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_SAMPLE_INTERVAL], SAMPLE_DEFULE_INTERVAL);
587 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_IGNORE_STARTUP_TIME], DEFAULT_IGNORE_STARTUP_TIME);
588 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_SAMPLE_COUNT], SAMPLE_DEFULE_COUNT);
589 printf("stackContent_.reportTimes: %d", WatchdogInner::GetInstance().stackContent_.reportTimes);
590 }
591
592 /**
593 * @tc.name: WatchdogInner SetEventConfig test;
594 * @tc.desc: set log_type is 2.
595 * @tc.type: FUNC
596 */
597 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_SetEventConfig_004, TestSize.Level1)
598 {
599 WatchdogInner::GetInstance().InitMainLooperWatcher(nullptr, nullptr);
600 WatchdogInnerBeginFunc beginTest = InitBeginFuncTest;
601 WatchdogInnerEndFunc endTest = InitEndFuncTest;
602 WatchdogInner::GetInstance().InitMainLooperWatcher(&beginTest, &endTest);
603
604 std::map<std::string, std::string> paramsMap;
605 paramsMap[KEY_LOG_TYPE] = "2";
606 int ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
607 EXPECT_EQ(ret, 0);
608 beginTest("Test");
609 usleep(2000 * 1000); // test value
610 endTest("Test");
611 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_LOG_TYPE], 2);
612 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_SAMPLE_INTERVAL], SAMPLE_DEFULE_INTERVAL);
613 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_IGNORE_STARTUP_TIME], DEFAULT_IGNORE_STARTUP_TIME);
614 EXPECT_EQ(WatchdogInner::GetInstance().jankParamsMap[KEY_SAMPLE_COUNT], SAMPLE_DEFULE_COUNT);
615 }
616
617 /**
618 * @tc.name: WatchdogInner SetEventConfig test;
619 * @tc.desc: set KEY_LOG_TYPE is 1, other parameters out of range.
620 * @tc.type: FUNC
621 */
622 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_SetEventConfig_005, TestSize.Level1)
623 {
624 std::map<std::string, std::string> paramsMap;
625 /**
626 * @tc.desc: set KEY_SAMPLE_INTERVAL out of range.
627 */
628 paramsMap[KEY_LOG_TYPE] = "1";
629 paramsMap[KEY_SAMPLE_INTERVAL] = "49";
630 paramsMap[KEY_IGNORE_STARTUP_TIME] = "15";
631 paramsMap[KEY_SAMPLE_COUNT] = "21";
632 paramsMap[KEY_SAMPLE_REPORT_TIMES] = "3";
633 int ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
634 EXPECT_EQ(ret, -1);
635 /**
636 * @tc.desc: set KEY_SAMPLE_INTERVAL out of range.
637 */
638 paramsMap[KEY_SAMPLE_INTERVAL] = "50";
639 paramsMap[KEY_IGNORE_STARTUP_TIME] = "1";
640 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
641 EXPECT_EQ(ret, -1);
642 /**
643 * @tc.desc: set KEY_SAMPLE_INTERVAL out of range.
644 */
645 paramsMap[KEY_SAMPLE_INTERVAL] = "100";
646 paramsMap[KEY_IGNORE_STARTUP_TIME] = "1";
647 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
648 EXPECT_EQ(ret, -1);
649 /**
650 * @tc.desc: set KEY_SAMPLE_INTERVAL out of range.
651 */
652 paramsMap[KEY_IGNORE_STARTUP_TIME] = "10";
653 paramsMap[KEY_SAMPLE_COUNT] = "1000";
654 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
655 EXPECT_EQ(ret, -1);
656 /**
657 * @tc.desc: set KEY_SAMPLE_INTERVAL out of range.
658 */
659 paramsMap[KEY_SAMPLE_COUNT] = "10";
660 paramsMap[KEY_SAMPLE_REPORT_TIMES] = "5";
661 ret = WatchdogInner::GetInstance().SetEventConfig(paramsMap);
662 EXPECT_EQ(ret, -1);
663 }
664
665 /**
666 * @tc.name: WatchdogInner GetLimitedSizeName test;
667 * @tc.desc: add testcase
668 * @tc.type: FUNC
669 */
670 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_GetLimitedSizeName_001, TestSize.Level1)
671 {
672 std::string testStr = "WatchdogInnerTest_GetLimitedSizeName_001";
673 std::string name = testStr;
674 int limitValue = 128; // name limit value
675 while (name.size() <= limitValue) {
676 name += testStr;
677 }
678 EXPECT_TRUE(GetLimitedSizeName(name).size() <= limitValue);
679 }
680
681 /**
682 * @tc.name: WatchdogInner GetAppStartTime test;
683 * @tc.desc: add testcase
684 * @tc.type: FUNC
685 */
686 HWTEST_F(WatchdogInnerTest, WatchdogInnerTest_GetAppStartTime_001, TestSize.Level1)
687 {
688 std::string testStr = "WatchdogInnerTest_GetAppStartTime_001";
689 int64_t time = GetAppStartTime(-1, 0);
690 EXPECT_TRUE(time != 0);
691 }
692 } // namespace HiviewDFX
693 } // namespace OHOS
694