1 /*
2 * Copyright (C) 2024 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 "watchdog_unit_test.h"
17
18 #include <thread>
19
20 using namespace OHOS;
21 using namespace OHOS::Media;
22 using namespace std;
23 using namespace testing::ext;
24
25 namespace {
26 constexpr uint32_t TIMEOUT_MS = 1000;
27 }
28
29 namespace OHOS {
30 namespace Media {
31 namespace Test {
SetUpTestCase(void)32 void WatchdogUnitTest::SetUpTestCase(void) {}
33
TearDownTestCase(void)34 void WatchdogUnitTest::TearDownTestCase(void) {}
35
SetUp(void)36 void WatchdogUnitTest::SetUp(void)
37 {
38 watchDog_ = std::make_shared<WatchDog>(TIMEOUT_MS);
39 }
40
TearDown(void)41 void WatchdogUnitTest::TearDown(void)
42 {
43 watchDog_ = nullptr;
44 }
45
46 /**
47 * @tc.name: PauseWatchDog
48 * @tc.desc: PauseWatchDog
49 * @tc.type: FUNC
50 */
51 HWTEST_F(WatchdogUnitTest, PauseWatchDog, TestSize.Level1)
52 {
53 watchDog_->enable_ = false;
54 watchDog_->PauseWatchDog();
55
56 watchDog_->enable_ = true;
57 watchDog_->pause_ = false;
58 watchDog_->paused_ = false;
59 watchDog_->PauseWatchDog();
60 ASSERT_EQ(watchDog_->pause_, true);
61 }
62
63 /**
64 * @tc.name: ResumeWatchDog
65 * @tc.desc: ResumeWatchDog
66 * @tc.type: FUNC
67 */
68 HWTEST_F(WatchdogUnitTest, ResumeWatchDog, TestSize.Level1)
69 {
70 watchDog_->pause_ = true;
71 watchDog_->enable_ = false;
72 watchDog_->ResumeWatchDog();
73 ASSERT_EQ(watchDog_->pause_, true);
74
75 watchDog_->pause_ = true;
76 watchDog_->enable_ = true;
77 watchDog_->ResumeWatchDog();
78 ASSERT_EQ(watchDog_->pause_, false);
79 }
80
81 /**
82 * @tc.name: Notify
83 * @tc.desc: Notify
84 * @tc.type: FUNC
85 */
86 HWTEST_F(WatchdogUnitTest, Notify, TestSize.Level1)
87 {
88 watchDog_->pause_ = true;
89 watchDog_->enable_ = false;
90 watchDog_->alarmed_ = false;
91 watchDog_->count_ = 0;
92 watchDog_->Notify();
93 ASSERT_EQ(watchDog_->pause_, true);
94 ASSERT_EQ(watchDog_->alarmed_, false);
95 ASSERT_EQ(watchDog_->count_, 0);
96
97 watchDog_->pause_ = true;
98 watchDog_->enable_ = true;
99 watchDog_->alarmed_ = false;
100 watchDog_->count_ = 0;
101 watchDog_->Notify();
102 ASSERT_EQ(watchDog_->pause_, true);
103 ASSERT_EQ(watchDog_->alarmed_, false);
104 ASSERT_EQ(watchDog_->count_, 1);
105
106 watchDog_->pause_ = true;
107 watchDog_->enable_ = true;
108 watchDog_->alarmed_ = true;
109 watchDog_->count_ = 0;
110 watchDog_->Notify();
111 ASSERT_EQ(watchDog_->pause_, false);
112 ASSERT_EQ(watchDog_->alarmed_, false);
113 ASSERT_EQ(watchDog_->count_, 1);
114 }
115
116 /**
117 * @tc.name: ResumeWatchDog
118 * @tc.desc: ResumeWatchDog
119 * @tc.type: FUNC
120 */
121 HWTEST_F(WatchdogUnitTest, WatchDogThread, TestSize.Level1)
122 {
123 watchDog_->enable_ = false;
124 watchDog_->pause_ = true;
125 watchDog_->WatchDogThread();
126 ASSERT_EQ(watchDog_->pause_, true);
127
128 watchDog_->enable_ = false;
129 watchDog_->pause_ = false;
130 watchDog_->WatchDogThread();
131 ASSERT_EQ(watchDog_->pause_, false);
132
__anondb5c47250202null133 std::thread t([&watchDog = watchDog_] {
134 usleep(500 * 1000);
135 watchDog->enable_ = false;
136 std::unique_lock<std::mutex> lock(watchDog->mutex_);
137 watchDog->cond_.notify_all();
138 });
139
140 watchDog_->enable_ = true;
141 watchDog_->pause_ = false;
142 watchDog_->count_ = 1;
143 watchDog_->paused_ = true;
144 watchDog_->alarmed_ = true;
145 watchDog_->WatchDogThread();
146 ASSERT_EQ(watchDog_->pause_, false);
147
148 if (t.joinable()) {
149 t.join();
150 }
151
__anondb5c47250302null152 std::thread t1([&watchDog = watchDog_] {
153 usleep(500 * 1000);
154 watchDog->enable_ = false;
155 std::unique_lock<std::mutex> lock(watchDog->mutex_);
156 watchDog->cond_.notify_all();
157 });
158
159 watchDog_->enable_ = true;
160 watchDog_->pause_ = false;
161 watchDog_->count_ = 1;
162 watchDog_->paused_ = true;
163 watchDog_->alarmed_ = false;
164 watchDog_->WatchDogThread();
165 ASSERT_EQ(watchDog_->pause_, false);
166
167 if (t1.joinable()) {
168 t1.join();
169 }
170 }
171 } // namespace Test
172 } // namespace Media
173 } // namespace OHOS
174