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