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_chart.h"
17 #include <climits>
18 #include <gtest/gtest.h>
19
20 using namespace testing::ext;
21
22 namespace OHOS {
23 namespace {
24 const uint16_t ARRAY_SIZE = 5;
25 const uint16_t RADIUS = 5;
26 const uint16_t WIDTH = 10;
27 const Point POINT_ARRAY[ARRAY_SIZE] = { {0, 2478}, {1, 2600}, {2, 3000}, {3, 3200}, {4, 3500} };
28 }
29
30 class UIChartDataSerialTest : public testing::Test {
31 public:
UIChartDataSerialTest()32 UIChartDataSerialTest() : chartDataSerial_(nullptr), chart_(nullptr) {}
~UIChartDataSerialTest()33 ~UIChartDataSerialTest() {}
SetUpTestCase(void)34 static void SetUpTestCase(void) {}
TearDownTestCase(void)35 static void TearDownTestCase(void) {}
36 void SetUp(void);
37 void TearDowm(void);
38 UIChartDataSerial* chartDataSerial_;
39 UIChartPillar* chart_;
40 };
41
SetUp(void)42 void UIChartDataSerialTest::SetUp(void)
43 {
44 if (chartDataSerial_ == nullptr) {
45 chartDataSerial_ = new UIChartDataSerial();
46 chartDataSerial_->SetMaxDataCount(ARRAY_SIZE);
47 }
48 if (chart_ == nullptr) {
49 chart_ = new UIChartPillar();
50 }
51 }
52
TearDowm(void)53 void UIChartDataSerialTest::TearDowm(void)
54 {
55 if (chartDataSerial_ != nullptr) {
56 delete chartDataSerial_;
57 chartDataSerial_ = nullptr;
58 }
59 if (chart_ != nullptr) {
60 delete chart_;
61 chart_ = nullptr;
62 }
63 }
64
InitPointStyle(UIChartDataSerial::PointStyle & pointStyle)65 void InitPointStyle(UIChartDataSerial::PointStyle& pointStyle)
66 {
67 pointStyle.fillColor = Color::Red();
68 pointStyle.radius = RADIUS;
69 pointStyle.strokeColor = Color::White();
70 pointStyle.strokeWidth = WIDTH;
71 }
72
73 /**
74 * @tc.name: UIChartDataSerialSetMaxDataCount_001
75 * @tc.desc: Verify SetMaxDataCount function, equal.
76 * @tc.type: FUNC
77 * @tc.require: AR000EEMQ8
78 */
79 HWTEST_F(UIChartDataSerialTest, UIChartDataSerialSetMaxDataCount_001, TestSize.Level1)
80 {
81 if (chartDataSerial_ == nullptr) {
82 EXPECT_EQ(1, 0);
83 return;
84 }
85 EXPECT_EQ(chartDataSerial_->SetMaxDataCount(1), true);
86 }
87
88 /**
89 * @tc.name: UIChartDataSerialAddPoints_001
90 * @tc.desc: Verify AddPoints function, equal.
91 * @tc.type: FUNC
92 * @tc.require: AR000EEMQ8
93 */
94 HWTEST_F(UIChartDataSerialTest, UIChartDataSerialAddPoints_001, TestSize.Level1)
95 {
96 if (chartDataSerial_ == nullptr) {
97 EXPECT_EQ(1, 0);
98 return;
99 }
100 bool ret = chartDataSerial_->AddPoints(nullptr, 0);
101 EXPECT_EQ(ret, false);
102 ret = chartDataSerial_->AddPoints(POINT_ARRAY, ARRAY_SIZE);
103 EXPECT_EQ(ret, true);
104 ret = chartDataSerial_->AddPoints(POINT_ARRAY, 0);
105 EXPECT_EQ(ret, false);
106 }
107
108 /**
109 * @tc.name: UIChartDataSerialGetPoint_001
110 * @tc.desc: Verify GetPoint function, equal.
111 * @tc.type: FUNC
112 * @tc.require: AR000EEMQ8
113 */
114 HWTEST_F(UIChartDataSerialTest, UIChartDataSerialGetPoint_001, TestSize.Level1)
115 {
116 if (chartDataSerial_ == nullptr) {
117 EXPECT_EQ(1, 0);
118 return;
119 }
120 Point point;
121
122 bool ret = chartDataSerial_->AddPoints(POINT_ARRAY, ARRAY_SIZE);
123 EXPECT_EQ(ret, true);
124 ret = chartDataSerial_->GetPoint(1, point);
125 EXPECT_EQ(ret, true);
126 EXPECT_EQ(point.x, POINT_ARRAY[1].x);
127 EXPECT_EQ(point.y, POINT_ARRAY[1].y);
128 }
129
130 /**
131 * @tc.name: UIChartDataSerialModifyPoint_001
132 * @tc.desc: Verify ModifyPoint function, equal.
133 * @tc.type: FUNC
134 * @tc.require: AR000EEMQ8
135 */
136 HWTEST_F(UIChartDataSerialTest, UIChartDataSerialModifyPoint_001, TestSize.Level0)
137 {
138 if (chartDataSerial_ == nullptr) {
139 EXPECT_EQ(1, 0);
140 return;
141 }
142 Point point = { 1, 200 }; // 200 : y posetion
143 Point point1;
144
145 bool ret = chartDataSerial_->AddPoints(POINT_ARRAY, ARRAY_SIZE);
146 EXPECT_EQ(ret, true);
147 ret = chartDataSerial_->ModifyPoint(ARRAY_SIZE + 1, point);
148 EXPECT_EQ(ret, false);
149 ret = chartDataSerial_->ModifyPoint(1, point);
150 EXPECT_EQ(ret, true);
151 ret = chartDataSerial_->GetPoint(1, point1);
152 EXPECT_EQ(ret, true);
153 EXPECT_EQ(point1.x, point.x);
154 EXPECT_EQ(point1.y, point.y);
155 }
156
157 /**
158 * @tc.name: UIChartDataSerialClearData_001
159 * @tc.desc: Verify ClearData function, equal.
160 * @tc.type: FUNC
161 * @tc.require: AR000EEMQ8
162 */
163 HWTEST_F(UIChartDataSerialTest, UIChartDataSerialClearData_001, TestSize.Level1)
164 {
165 if (chartDataSerial_ == nullptr) {
166 EXPECT_EQ(1, 0);
167 return;
168 }
169 Point point;
170
171 bool ret = chartDataSerial_->AddPoints(POINT_ARRAY, ARRAY_SIZE);
172 EXPECT_EQ(ret, true);
173 chartDataSerial_->ClearData();
174 ret = chartDataSerial_->GetPoint(1, point);
175 EXPECT_EQ(ret, false);
176 }
177
178 /**
179 * @tc.name: UIChartDataSerialGetDataCount_001
180 * @tc.desc: Verify GetDataCount function, equal.
181 * @tc.type: FUNC
182 * @tc.require: AR000EEMQ8
183 */
184 HWTEST_F(UIChartDataSerialTest, UIChartDataSerialGetDataCount_001, TestSize.Level1)
185 {
186 if (chartDataSerial_ == nullptr) {
187 EXPECT_EQ(1, 0);
188 return;
189 }
190 bool ret = chartDataSerial_->AddPoints(POINT_ARRAY, ARRAY_SIZE);
191 EXPECT_EQ(ret, true);
192 uint16_t count = chartDataSerial_->GetDataCount();
193 EXPECT_EQ(count, ARRAY_SIZE);
194 chartDataSerial_->ClearData();
195 count = chartDataSerial_->GetDataCount();
196 EXPECT_EQ(count, 0);
197 }
198
199 /**
200 * @tc.name: UIChartDataSerialEnableGradient_001
201 * @tc.desc: Verify EnableGradient function, equal.
202 * @tc.type: FUNC
203 * @tc.require: AR000EEMQ8
204 */
205 HWTEST_F(UIChartDataSerialTest, UIChartDataSerialEnableGradient_001, TestSize.Level1)
206 {
207 if (chartDataSerial_ == nullptr) {
208 EXPECT_EQ(1, 0);
209 return;
210 }
211 chartDataSerial_->EnableGradient(true);
212 EXPECT_EQ(chartDataSerial_->IsGradient(), true);
213 }
214
215 /**
216 * @tc.name: UIChartDataSerialEnableSmooth_001
217 * @tc.desc: Verify EnableSmooth function, equal.
218 * @tc.type: FUNC
219 * @tc.require: AR000EEMQ8
220 */
221 HWTEST_F(UIChartDataSerialTest, UIChartDataSerialEnableSmooth_001, TestSize.Level1)
222 {
223 if (chartDataSerial_ == nullptr) {
224 EXPECT_EQ(1, 0);
225 return;
226 }
227 chartDataSerial_->EnableSmooth(true);
228 bool ret = chartDataSerial_->IsSmooth();
229 EXPECT_EQ(ret, true);
230 }
231
232 /**
233 * @tc.name: UIChartDataSerialGetPeakIndex_001
234 * @tc.desc: Verify GetPeakIndex function, equal.
235 * @tc.type: FUNC
236 * @tc.require: AR000EEMQ8
237 */
238 HWTEST_F(UIChartDataSerialTest, UIChartDataSerialGetPeakIndex_001, TestSize.Level1)
239 {
240 if (chartDataSerial_ == nullptr) {
241 EXPECT_EQ(1, 0);
242 return;
243 }
244 bool ret = chartDataSerial_->AddPoints(POINT_ARRAY, ARRAY_SIZE);
245 EXPECT_EQ(ret, true);
246 uint16_t index = chartDataSerial_->GetPeakIndex();
247 EXPECT_EQ(index, 4);
248 int16_t value = chartDataSerial_->GetPeakData();
249 EXPECT_EQ(value, 3500);
250 }
251
252 /**
253 * @tc.name: UIChartDataSerialGetValleyIndex_001
254 * @tc.desc: Verify GetValleyIndex function, equal.
255 * @tc.type: FUNC
256 * @tc.require: AR000EEMQ8
257 */
258 HWTEST_F(UIChartDataSerialTest, UIChartDataSerialGetValleyIndex_001, TestSize.Level1)
259 {
260 if (chartDataSerial_ == nullptr) {
261 EXPECT_EQ(1, 0);
262 return;
263 }
264 bool ret = chartDataSerial_->AddPoints(POINT_ARRAY, ARRAY_SIZE);
265 EXPECT_EQ(ret, true);
266 uint16_t index = chartDataSerial_->GetValleyIndex();
267 EXPECT_EQ(index, 0);
268 }
269
270 /**
271 * @tc.name: UIChartDataSerialGetLatestIndex_001
272 * @tc.desc: Verify GetLatestIndex function, equal.
273 * @tc.type: FUNC
274 * @tc.require: AR000EEMQ8
275 */
276 HWTEST_F(UIChartDataSerialTest, UIChartDataSerialGetLatestIndex_001, TestSize.Level1)
277 {
278 if (chartDataSerial_ == nullptr) {
279 EXPECT_EQ(1, 0);
280 return;
281 }
282 bool ret = chartDataSerial_->AddPoints(POINT_ARRAY, ARRAY_SIZE);
283 EXPECT_EQ(ret, true);
284 uint16_t index = chartDataSerial_->GetLatestIndex();
285 EXPECT_EQ(index, ARRAY_SIZE - 1);
286 }
287
288 /**
289 * @tc.name: UIChartDataSerialSetLastPointIndex_001
290 * @tc.desc: Verify SetLastPointIndex function, equal.
291 * @tc.type: FUNC
292 * @tc.require: AR000EEMQ8
293 */
294 HWTEST_F(UIChartDataSerialTest, UIChartDataSerialSetLastPointIndex_001, TestSize.Level1)
295 {
296 if (chartDataSerial_ == nullptr) {
297 EXPECT_EQ(1, 0);
298 return;
299 }
300 bool ret = chartDataSerial_->AddPoints(POINT_ARRAY, ARRAY_SIZE);
301 EXPECT_EQ(ret, true);
302 uint16_t index = chartDataSerial_->GetLastPointIndex();
303 EXPECT_EQ(index, 0);
304 const uint16_t lastPointIndex = 4;
305 chartDataSerial_->SetLastPointIndex(lastPointIndex);
306 EXPECT_EQ(chartDataSerial_->GetLastPointIndex(), lastPointIndex);
307 }
308
309 /**
310 * @tc.name: UIChartDataSerialSetLineColor_001
311 * @tc.desc: Verify SetLineColor function, equal.
312 * @tc.type: FUNC
313 * @tc.require: AR000EEMQ8
314 */
315 HWTEST_F(UIChartDataSerialTest, UIChartDataSerialSetLineColor_001, TestSize.Level1)
316 {
317 if (chartDataSerial_ == nullptr) {
318 EXPECT_EQ(1, 0);
319 return;
320 }
321 ColorType color = Color::Red();
322 chartDataSerial_->SetLineColor(color);
323 EXPECT_EQ(chartDataSerial_->GetLineColor().full, color.full);
324 }
325
326 /**
327 * @tc.name: UIChartDataSerialSetFillColor_001
328 * @tc.desc: Verify SetFillColor function, equal.
329 * @tc.type: FUNC
330 * @tc.require: AR000EEMQ8
331 */
332 HWTEST_F(UIChartDataSerialTest, UIChartDataSerialSetFillColor_001, TestSize.Level1)
333 {
334 if (chartDataSerial_ == nullptr) {
335 EXPECT_EQ(1, 0);
336 return;
337 }
338 ColorType color = Color::Red();
339 chartDataSerial_->SetFillColor(color);
340 EXPECT_EQ(chartDataSerial_->GetFillColor().full, color.full);
341 }
342
343 /**
344 * @tc.name: UIChartDataSerialHidePoint_001
345 * @tc.desc: Verify HidePoint function, equal.
346 * @tc.type: FUNC
347 * @tc.require: AR000EEMQ8
348 */
349 HWTEST_F(UIChartDataSerialTest, UIChartDataSerialHidePoint_001, TestSize.Level1)
350 {
351 if (chartDataSerial_ == nullptr) {
352 EXPECT_EQ(1, 0);
353 return;
354 }
355 const uint16_t index = 3;
356 const uint16_t count = 5;
357 chartDataSerial_->HidePoint(index, count);
358 EXPECT_EQ(chartDataSerial_->GetHideIndex(), index);
359 EXPECT_EQ(chartDataSerial_->GetHideCount(), count);
360 }
361
362 /**
363 * @tc.name: UIChartDataSerialSetHeadPointStyle_001
364 * @tc.desc: Verify SetHeadPointStyle function, equal.
365 * @tc.type: FUNC
366 * @tc.require: AR000EEMQ8
367 */
368 HWTEST_F(UIChartDataSerialTest, UIChartDataSerialSetHeadPointStyle_001, TestSize.Level0)
369 {
370 if (chartDataSerial_ == nullptr) {
371 EXPECT_EQ(1, 0);
372 return;
373 }
374 UIChartDataSerial::PointStyle pointStyle;
375 InitPointStyle(pointStyle);
376
377 chartDataSerial_->SetHeadPointStyle(pointStyle);
378 UIChartDataSerial::PointStyle pointStyle1 = chartDataSerial_->GetHeadPointStyle();
379 EXPECT_EQ(pointStyle1.fillColor.full, pointStyle.fillColor.full);
380 EXPECT_EQ(pointStyle1.strokeColor.full, pointStyle.strokeColor.full);
381 EXPECT_EQ(pointStyle1.strokeWidth, pointStyle.strokeWidth);
382 EXPECT_EQ(pointStyle1.radius, pointStyle.radius);
383 }
384
385 /**
386 * @tc.name: UIChartDataSerialSetTopPointStyle_001
387 * @tc.desc: Verify SetTopPointStyle function, equal.
388 * @tc.type: FUNC
389 * @tc.require: AR000EEMQ8
390 */
391 HWTEST_F(UIChartDataSerialTest, UIChartDataSerialSetTopPointStyle_001, TestSize.Level0)
392 {
393 if (chartDataSerial_ == nullptr) {
394 EXPECT_EQ(1, 0);
395 return;
396 }
397 UIChartDataSerial::PointStyle pointStyle;
398 InitPointStyle(pointStyle);
399
400 chartDataSerial_->SetTopPointStyle(pointStyle);
401 UIChartDataSerial::PointStyle pointStyle1 = chartDataSerial_->GetTopPointStyle();
402 EXPECT_EQ(pointStyle1.fillColor.full, pointStyle.fillColor.full);
403 EXPECT_EQ(pointStyle1.strokeColor.full, pointStyle.strokeColor.full);
404 EXPECT_EQ(pointStyle1.strokeWidth, pointStyle.strokeWidth);
405 EXPECT_EQ(pointStyle1.radius, pointStyle.radius);
406 }
407
408 /**
409 * @tc.name: UIChartDataSerialSetBottomPointStyle_001
410 * @tc.desc: Verify SetBottomPointStyle function, equal.
411 * @tc.type: FUNC
412 * @tc.require: AR000EEMQ8
413 */
414 HWTEST_F(UIChartDataSerialTest, UIChartDataSerialSetBottomPointStyle_001, TestSize.Level0)
415 {
416 if (chartDataSerial_ == nullptr) {
417 EXPECT_EQ(1, 0);
418 return;
419 }
420 UIChartDataSerial::PointStyle pointStyle;
421 InitPointStyle(pointStyle);
422
423 chartDataSerial_->SetBottomPointStyle(pointStyle);
424 UIChartDataSerial::PointStyle pointStyle1 = chartDataSerial_->GetBottomPointStyle();
425 EXPECT_EQ(pointStyle1.fillColor.full, pointStyle.fillColor.full);
426 EXPECT_EQ(pointStyle1.strokeColor.full, pointStyle.strokeColor.full);
427 EXPECT_EQ(pointStyle1.strokeWidth, pointStyle.strokeWidth);
428 EXPECT_EQ(pointStyle1.radius, pointStyle.radius);
429 }
430
431 /**
432 * @tc.name: UIChartAddDataSerial_001
433 * @tc.desc: Verify AddDataSerial function, equal.
434 * @tc.type: FUNC
435 * @tc.require: AR000EEMQ8
436 */
437 HWTEST_F(UIChartDataSerialTest, UIChartAddDataSerial_001, TestSize.Level1)
438 {
439 if (chart_ == nullptr) {
440 EXPECT_EQ(1, 0);
441 return;
442 }
443 bool ret = chart_->AddDataSerial(nullptr);
444 EXPECT_EQ(ret, false);
445 ret = chart_->AddDataSerial(chartDataSerial_);
446 EXPECT_EQ(ret, true);
447 ret = chart_->AddDataSerial(chartDataSerial_);
448 EXPECT_EQ(ret, false);
449 }
450
451 /**
452 * @tc.name: UIChartDeleteDataSerial_001
453 * @tc.desc: Verify DeleteDataSerial function, equal.
454 * @tc.type: FUNC
455 * @tc.require: AR000EEMQ8
456 */
457 HWTEST_F(UIChartDataSerialTest, UIChartDeleteDataSerial_001, TestSize.Level1)
458 {
459 if (chart_ == nullptr) {
460 EXPECT_EQ(1, 0);
461 return;
462 }
463 bool ret = chart_->DeleteDataSerial(nullptr);
464 EXPECT_EQ(ret, false);
465 ret = chart_->DeleteDataSerial(chartDataSerial_);
466 EXPECT_EQ(ret, false);
467 ret = chart_->AddDataSerial(chartDataSerial_);
468 EXPECT_EQ(ret, true);
469 ret = chart_->DeleteDataSerial(chartDataSerial_);
470 EXPECT_EQ(ret, true);
471 }
472
473 /**
474 * @tc.name: UIChartClearDataSerial_001
475 * @tc.desc: Verify ClearDataSerial function, equal.
476 * @tc.type: FUNC
477 * @tc.require: AR000EEMQ8
478 */
479 HWTEST_F(UIChartDataSerialTest, UIChartClearDataSerial_001, TestSize.Level1)
480 {
481 if (chart_ == nullptr) {
482 EXPECT_EQ(1, 0);
483 return;
484 }
485 bool ret = chart_->AddDataSerial(chartDataSerial_);
486 EXPECT_EQ(ret, true);
487 chart_->ClearDataSerial();
488 ret = chart_->DeleteDataSerial(chartDataSerial_);
489 EXPECT_EQ(ret, false);
490 }
491
492 /**
493 * @tc.name: UIChartGetValleyData_001
494 * @tc.desc: Verify GetValleyData function, equal.
495 */
496 HWTEST_F(UIChartDataSerialTest, UIChartGetValleyData_001, TestSize.Level1)
497 {
498 if (chart_ == nullptr) {
499 EXPECT_EQ(1, 0);
500 return;
501 }
502 UIChart* chart = static_cast<UIChart*>(chart_);
503 chartDataSerial_->BindToChart(chart);
504 bool flag = true;
505 chartDataSerial_->EnableHeadPoint(flag);
506 chartDataSerial_->EnableTopPoint(flag);
507 chartDataSerial_->EnableBottomPoint(flag);
508 EXPECT_EQ(chartDataSerial_->GetEnableHeadPoint(), flag);
509 EXPECT_EQ(chartDataSerial_->GetEnableTopPoint(), flag);
510 EXPECT_EQ(chartDataSerial_->GetEnableBottomPoint(), flag);
511
512 BufferInfo* gfxDstBuffer = new BufferInfo();
513 Rect* mask = new Rect();
514 chartDataSerial_->DrawPoint(*gfxDstBuffer, *mask);
515 chartDataSerial_->Refresh();
516 EXPECT_EQ(chartDataSerial_->GetValleyData(), 0);
517 delete gfxDstBuffer;
518 gfxDstBuffer = nullptr;
519 delete mask;
520 mask = nullptr;
521 }
522 }
523