1 /*
2 * Copyright (c) 2020-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 "components/ui_analog_clock.h"
17 #include "components/ui_image_view.h"
18
19 #include <climits>
20 #include <gtest/gtest.h>
21
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace {
26 const uint8_t CURRENT_HOUR = 14;
27 const uint8_t CURRENT_MINUTE = 40;
28 const uint8_t CURRENT_SECOND = 30;
29 const uint8_t INIT_HOUR = 6;
30 const uint8_t INIT_MINUTE = 0;
31 const uint8_t INIT_SECOND = 0;
32 const uint8_t HALF_DAY_IN_HOUR = 12;
33 }
34
35 class UIAnalogClockTest : public testing::Test {
36 public:
37 static void SetUpTestCase(void);
38 static void TearDownTestCase(void);
39 static UIAnalogClock* clock_;
40 };
41
42 UIAnalogClock* UIAnalogClockTest::clock_ = nullptr;
43
SetUpTestCase()44 void UIAnalogClockTest::SetUpTestCase()
45 {
46 if (clock_ == nullptr) {
47 clock_ = new UIAnalogClock();
48 }
49 }
50
TearDownTestCase()51 void UIAnalogClockTest::TearDownTestCase()
52 {
53 if (clock_ != nullptr) {
54 delete clock_;
55 clock_ = nullptr;
56 }
57 }
58
59 /**
60 * @tc.name: UIAnalogClockGetViewType_001
61 * @tc.desc: Verify GetWidth and GetHeight function.
62 * @tc.type: FUNC
63 * @tc.require: AR000DSMQ1
64 */
65 HWTEST_F(UIAnalogClockTest, UIAnalogClockGetViewType_001, TestSize.Level1)
66 {
67 if (clock_ == nullptr) {
68 EXPECT_EQ(1, 0);
69 return;
70 }
71 EXPECT_EQ(clock_->GetViewType(), UI_ANALOG_CLOCK);
72 }
73
74 /**
75 * @tc.name: UIAnalogClockSetPosition_001
76 * @tc.desc: Verify GetWidth and GetHeight function.
77 * @tc.type: FUNC
78 * @tc.require: AR000DSMQ1
79 */
80 HWTEST_F(UIAnalogClockTest, UIAnalogClockSetPosition_001, TestSize.Level1)
81 {
82 if (clock_ == nullptr) {
83 EXPECT_EQ(1, 0);
84 return;
85 }
86 clock_->SetPosition(0, 0);
87 EXPECT_EQ(clock_->GetX(), 0);
88 EXPECT_EQ(clock_->GetY(), 0);
89 }
90
91 /**
92 * @tc.name: UIAnalogClockSetTime24Hour_001
93 * @tc.desc: Verify SetTime24Hour function, equal.
94 * @tc.type: FUNC
95 * @tc.require: AR000EEMQA
96 */
97 HWTEST_F(UIAnalogClockTest, UIAnalogClockSetTime24Hour_001, TestSize.Level1)
98 {
99 if (clock_ == nullptr) {
100 EXPECT_EQ(1, 0);
101 return;
102 }
103 clock_->SetTime24Hour(CURRENT_HOUR, CURRENT_MINUTE, CURRENT_SECOND);
104 EXPECT_EQ(clock_->GetCurrentHour(), CURRENT_HOUR);
105 EXPECT_EQ(clock_->GetCurrentMinute(), CURRENT_MINUTE);
106 EXPECT_EQ(clock_->GetCurrentSecond(), CURRENT_SECOND);
107 }
108
109 /**
110 * @tc.name: UIAnalogClockSetTime12Hour_001
111 * @tc.desc: Verify SetTime12Hour am function, equal.
112 * @tc.type: FUNC
113 * @tc.require: AR000EEMQA
114 */
115 HWTEST_F(UIAnalogClockTest, UIAnalogClockSetTime12Hour_001, TestSize.Level1)
116 {
117 if (clock_ == nullptr) {
118 EXPECT_EQ(1, 0);
119 return;
120 }
121 clock_->SetTime12Hour(CURRENT_HOUR, CURRENT_MINUTE, CURRENT_SECOND, true);
122 EXPECT_EQ(clock_->GetCurrentHour(), CURRENT_HOUR - HALF_DAY_IN_HOUR);
123 EXPECT_EQ(clock_->GetCurrentMinute(), CURRENT_MINUTE);
124 EXPECT_EQ(clock_->GetCurrentSecond(), CURRENT_SECOND);
125 }
126
127 /**
128 * @tc.name: UIAnalogClockSetTime12Hour_002
129 * @tc.desc: Verify SetTime12Hour pm function, equal.
130 * @tc.type: FUNC
131 * @tc.require: AR000EEMQA
132 */
133 HWTEST_F(UIAnalogClockTest, UIAnalogClockSetTime12Hour_002, TestSize.Level1)
134 {
135 if (clock_ == nullptr) {
136 EXPECT_EQ(1, 0);
137 return;
138 }
139 clock_->SetTime12Hour(CURRENT_HOUR, CURRENT_MINUTE, CURRENT_SECOND, false);
140 EXPECT_EQ(clock_->GetCurrentHour(), CURRENT_HOUR);
141 EXPECT_EQ(clock_->GetCurrentMinute(), CURRENT_MINUTE);
142 EXPECT_EQ(clock_->GetCurrentSecond(), CURRENT_SECOND);
143 }
144
145 /**
146 * @tc.name: UIAnalogClockSetHandLine_001
147 * @tc.desc: Verify SetHandLine function, equal.
148 * @tc.type: FUNC
149 * @tc.require: AR000EEMQA
150 */
151 HWTEST_F(UIAnalogClockTest, UIAnalogClockSetHandLine_001, TestSize.Level1)
152 {
153 if (clock_ == nullptr) {
154 EXPECT_EQ(1, 0);
155 return;
156 }
157 Point position = { 214, 3 }; // { 214, 3 } : the position of the line endpoint close
158 Point center = { 14, 223 }; // { 14, 223 }: the rotation center of this clock hand
159
160 clock_->SetHandLine(UIAnalogClock::HandType::SECOND_HAND,
161 position, center, Color::White(), 1, 223, OPA_OPAQUE); // 223:the height of this line
162 EXPECT_EQ(clock_->GetHandPosition(UIAnalogClock::HandType::SECOND_HAND).x, position.x);
163 EXPECT_EQ(clock_->GetHandPosition(UIAnalogClock::HandType::SECOND_HAND).y, position.y);
164 EXPECT_EQ(clock_->GetHandRotateCenter(UIAnalogClock::HandType::SECOND_HAND).x, center.x);
165 EXPECT_EQ(clock_->GetHandRotateCenter(UIAnalogClock::HandType::SECOND_HAND).y, center.y);
166 }
167
168 /**
169 * @tc.name: UIAnalogClockSetInitTime24Hour_001
170 * @tc.desc: Verify SetInitTime24Hour function, equal.
171 * @tc.type: FUNC
172 * @tc.require: AR000EEMQA
173 */
174 HWTEST_F(UIAnalogClockTest, UIAnalogClockSetInitTime24Hour_001, TestSize.Level0)
175 {
176 if (clock_ == nullptr) {
177 EXPECT_EQ(1, 0);
178 return;
179 }
180 const uint8_t hour = 9;
181
182 clock_->SetInitTime24Hour(INIT_HOUR, INIT_MINUTE, INIT_SECOND);
183 EXPECT_EQ(clock_->GetCurrentHour(), INIT_HOUR);
184 EXPECT_EQ(clock_->GetCurrentMinute(), INIT_MINUTE);
185 EXPECT_EQ(clock_->GetCurrentSecond(), INIT_SECOND);
186 EXPECT_EQ(clock_->GetHandInitAngle(UIAnalogClock::HandType::HOUR_HAND), SEMICIRCLE_IN_DEGREE);
187 EXPECT_EQ(clock_->GetHandCurrentAngle(UIAnalogClock::HandType::HOUR_HAND), SEMICIRCLE_IN_DEGREE);
188
189 clock_->SetTime24Hour(hour, 0, 0);
190 EXPECT_EQ(clock_->GetHandInitAngle(UIAnalogClock::HandType::HOUR_HAND), SEMICIRCLE_IN_DEGREE);
191 EXPECT_EQ(clock_->GetHandCurrentAngle(UIAnalogClock::HandType::HOUR_HAND), THREE_QUARTER_IN_DEGREE);
192 }
193
194 /**
195 * @tc.name: UIAnalogClockSetInitTime12Hour_001
196 * @tc.desc: Verify SetInitTime12Hour am function, equal.
197 * @tc.type: FUNC
198 * @tc.require: AR000EEMQA
199 */
200 HWTEST_F(UIAnalogClockTest, UIAnalogClockSetInitTime12Hour_001, TestSize.Level1)
201 {
202 if (clock_ == nullptr) {
203 EXPECT_EQ(1, 0);
204 return;
205 }
206 clock_->SetInitTime12Hour(INIT_HOUR, INIT_MINUTE, INIT_SECOND, true);
207 EXPECT_EQ(clock_->GetCurrentHour(), INIT_HOUR);
208 EXPECT_EQ(clock_->GetCurrentMinute(), INIT_MINUTE);
209 EXPECT_EQ(clock_->GetCurrentSecond(), INIT_SECOND);
210 EXPECT_EQ(clock_->GetHandInitAngle(UIAnalogClock::HandType::HOUR_HAND), SEMICIRCLE_IN_DEGREE);
211 EXPECT_EQ(clock_->GetHandCurrentAngle(UIAnalogClock::HandType::HOUR_HAND), SEMICIRCLE_IN_DEGREE);
212 }
213
214 /**
215 * @tc.name: UIAnalogClockSetInitTime12Hour_002
216 * @tc.desc: Verify SetInitTime12Hour pm function, equal.
217 * @tc.type: FUNC
218 * @tc.require: AR000EEMQA
219 */
220 HWTEST_F(UIAnalogClockTest, UIAnalogClockSetInitTime12Hour_002, TestSize.Level1)
221 {
222 if (clock_ == nullptr) {
223 EXPECT_EQ(1, 0);
224 return;
225 }
226 clock_->SetInitTime12Hour(INIT_HOUR, INIT_MINUTE, INIT_SECOND, false);
227 EXPECT_EQ(clock_->GetCurrentHour(), INIT_HOUR + HALF_DAY_IN_HOUR);
228 EXPECT_EQ(clock_->GetCurrentMinute(), INIT_MINUTE);
229 EXPECT_EQ(clock_->GetCurrentSecond(), INIT_SECOND);
230 EXPECT_EQ(clock_->GetHandInitAngle(UIAnalogClock::HandType::HOUR_HAND), SEMICIRCLE_IN_DEGREE);
231 EXPECT_EQ(clock_->GetHandCurrentAngle(UIAnalogClock::HandType::HOUR_HAND), SEMICIRCLE_IN_DEGREE);
232 }
233
234 /**
235 * @tc.name: UIAnalogClockSetHandImage_001
236 * @tc.desc: Verify SetHandImage function, equal.
237 */
238 HWTEST_F(UIAnalogClockTest, UIAnalogClockSetHandImage_001, TestSize.Level1)
239 {
240 if (clock_ == nullptr) {
241 EXPECT_EQ(1, 0);
242 return;
243 }
244 UIImageView* img = new UIImageView();
245 Point position = { 214, 3 }; // { 214, 3 } : the position of the line endpoint close
246 Point center = { 14, 223 }; // { 14, 223 }: the rotation center of this clock hand
247 clock_->SetHandImage(UIAnalogClock::HandType::SECOND_HAND, *img, position, center);
248 EXPECT_EQ(clock_->GetHandPosition(UIAnalogClock::HandType::SECOND_HAND).x, position.x);
249 EXPECT_EQ(clock_->GetHandPosition(UIAnalogClock::HandType::SECOND_HAND).y, position.y);
250 EXPECT_EQ(clock_->GetHandRotateCenter(UIAnalogClock::HandType::SECOND_HAND).x, center.x);
251 EXPECT_EQ(clock_->GetHandRotateCenter(UIAnalogClock::HandType::SECOND_HAND).y, center.y);
252 delete img;
253 img = nullptr;
254 }
255
256 /**
257 * @tc.name: UIAnalogClockSetWorkMode_001
258 * @tc.desc: Verify SetWorkMode function, equal.
259 */
260 HWTEST_F(UIAnalogClockTest, UIAnalogClockSetWorkMode_001, TestSize.Level1)
261 {
262 if (clock_ == nullptr) {
263 EXPECT_EQ(1, 0);
264 return;
265 }
266 clock_->SetWorkMode(UIAnalogClock::NORMAL);
267 EXPECT_EQ(clock_->GetWorkMode(), UIAnalogClock::NORMAL);
268 }
269 }
270