1 /*
2 * Copyright (c) 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 "handler_checker_test.h"
17
18 #include <atomic>
19 #include <thread>
20
21 #include "handler_checker.h"
22 #include "event_handler.h"
23 using namespace testing::ext;
24 using namespace OHOS::AppExecFwk;
25 namespace OHOS {
26 namespace HiviewDFX {
27 namespace {
28 class TestEventHandler : public EventHandler {
29 public:
TestEventHandler(const std::shared_ptr<EventRunner> & runner)30 explicit TestEventHandler(const std::shared_ptr<EventRunner> &runner)
31 : EventHandler(runner) {};
~TestEventHandler()32 ~TestEventHandler() {};
33 };
34 }
35
SetUpTestCase(void)36 void HandlerCheckerTest::SetUpTestCase(void)
37 {
38 printf("SetUpTestCase.\n");
39 }
40
TearDownTestCase(void)41 void HandlerCheckerTest::TearDownTestCase(void)
42 {
43 printf("TearDownTestCase.\n");
44 }
45
SetUp(void)46 void HandlerCheckerTest::SetUp(void)
47 {
48 printf("SetUp.\n");
49 }
50
TearDown(void)51 void HandlerCheckerTest::TearDown(void)
52 {
53 printf("TearDown.\n");
54 }
55
56 /**
57 * @tc.name: HandlerCheckerTest
58 * @tc.desc: code branch coverage
59 * @tc.type: FUNC
60 * @tc.require: SR000CPN2F AR000CTAMB
61 */
62 HWTEST_F(HandlerCheckerTest, HandlerCheckerTest_001, TestSize.Level3)
63 {
64 std::atomic<bool> flage = false;
__anon8ebacb3e0202() 65 auto blockFunc = [&flage]() {
66 printf("before block 30s in %d\n", getproctid());
67 sleep(3); // sleep 3s
68 printf("after block 30s in %d\n", getproctid());
69 flage = true;
70 };
71 auto runner = EventRunner::Create(true);
72 auto handler = std::make_shared<TestEventHandler>(runner);
73 HandlerChecker handlerChecker("HandlerCheckerTest_001", handler);
74 bool ret = handler->PostTask(blockFunc, "Block3", 0, EventQueue::Priority::IMMEDIATE);
75 ASSERT_EQ(ret, true);
76 handlerChecker.ScheduleCheck();
77 std::this_thread::sleep_for(std::chrono::milliseconds(500));
78 ASSERT_EQ(handlerChecker.GetCheckState(), CheckStatus::WAITED_HALF);
79 std::this_thread::sleep_for(std::chrono::milliseconds(500));
80 ASSERT_EQ(handlerChecker.GetCheckState(), CheckStatus::WAITING);
81 for (int i = 0; !flage; ++i) {
82 std::this_thread::sleep_for(std::chrono::milliseconds(500));
83 if (i > 5) {
84 FAIL();
85 }
86 }
87 printf("GetCheckState result: %d\n", handlerChecker.GetCheckState());
88 }
89
90 /**
91 * @tc.name: HandlerCheckerTest_002
92 * @tc.desc: code branch coverage
93 * @tc.type: FUNC
94 * @tc.require: SR000CPN2F AR000CTAMB
95 */
96 HWTEST_F(HandlerCheckerTest, HandlerCheckerTest_002, TestSize.Level3)
97 {
98 auto runner = EventRunner::Create(true);
99 auto handler = std::make_shared<TestEventHandler>(runner);
100 HandlerChecker handlerChecker("HandlerCheckerTest_002", handler);
101
102 std::string ret = handlerChecker.GetDumpInfo();
103 if (ret.find("EventHandler") == std::string::npos) {
104 FAIL();
105 }
106 ASSERT_NE(handlerChecker.GetHandler(), nullptr);
107 }
108
109 /**
110 * @tc.name: HandlerCheckerTest_003
111 * @tc.desc: code branch coverage
112 * @tc.type: FUNC
113 * @tc.require: SR000CPN2F AR000CTAMB
114 */
115 HWTEST_F(HandlerCheckerTest, HandlerCheckerTest_003, TestSize.Level3)
116 {
117 HandlerChecker handlerChecker("HandlerCheckerTest_003", nullptr);
118
119 std::string ret = handlerChecker.GetDumpInfo();
120 ASSERT_EQ(ret.empty(), true);
121 }
122
123 /**
124 * @tc.name: HandlerCheckerTest_004
125 * @tc.desc: code branch coverage
126 * @tc.type: FUNC
127 * @tc.require: SR000CPN2F AR000CTAMB
128 */
129 HWTEST_F(HandlerCheckerTest, HandlerCheckerTest_004, TestSize.Level3)
130 {
131 auto runner = EventRunner::Create(true);
132 auto handler = std::make_shared<TestEventHandler>(runner);
133 HandlerDumper handlerDumper;
134 handler->Dump(handlerDumper);
135 std::string ret = handlerDumper.GetDumpInfo();
136 if (ret.find("EventHandler") == std::string::npos) {
137 FAIL();
138 }
139
140 ASSERT_EQ(handlerDumper.GetTag(), "");
141 }
142 } // end of namespace HiviewDFX
143 } // end of namespace OHOS