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 "gtest/gtest.h"
17
18 #include "draw/pen.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace Rosen {
25 namespace Drawing {
26 class PenTest : public testing::Test {
27 public:
28 static void SetUpTestCase();
29 static void TearDownTestCase();
30 void SetUp() override;
31 void TearDown() override;
32 };
33
SetUpTestCase()34 void PenTest::SetUpTestCase() {}
TearDownTestCase()35 void PenTest::TearDownTestCase() {}
SetUp()36 void PenTest::SetUp() {}
TearDown()37 void PenTest::TearDown() {}
38
39 /**
40 * @tc.name: CreateAndDestroy001
41 * @tc.desc:
42 * @tc.type: FUNC
43 * @tc.require: AR000GGNV3
44 * @tc.author:
45 */
46 HWTEST_F(PenTest, CreateAndDestroy001, TestSize.Level1)
47 {
48 auto pen = std::make_unique<Pen>();
49 ASSERT_TRUE(pen != nullptr);
50 }
51
52 /**
53 * @tc.name: CopyConstructor001
54 * @tc.desc:
55 * @tc.type: FUNC
56 * @tc.require: AR000GGNV3
57 * @tc.author:
58 */
59 HWTEST_F(PenTest, CopyConstructor001, TestSize.Level1)
60 {
61 Pen oldPen;
62 Pen pen{oldPen};
63 ASSERT_TRUE(pen == oldPen);
64 pen.SetWidth(1);
65 ASSERT_TRUE(pen != oldPen);
66 }
67
68 /**
69 * @tc.name: CreateByColor001
70 * @tc.desc:
71 * @tc.type: FUNC
72 * @tc.require: AR000GGNV3
73 * @tc.author:
74 */
75 HWTEST_F(PenTest, CreateByColor001, TestSize.Level1)
76 {
77 Color color = Color(255, 255, 255, 255);
78 auto pen = std::make_unique<Pen>(color);
79 ASSERT_TRUE(pen != nullptr);
80 }
81
82 /**
83 * @tc.name: CreateByColor002
84 * @tc.desc:
85 * @tc.type: FUNC
86 * @tc.require: AR000GGNV3
87 * @tc.author:
88 */
89 HWTEST_F(PenTest, CreateByColor002, TestSize.Level1)
90 {
91 Color color = Color(11, 12, 13, 14);
92 auto pen = std::make_unique<Pen>(color);
93 ASSERT_TRUE(pen != nullptr);
94 }
95
96 /**
97 * @tc.name: CreateByRGBA001
98 * @tc.desc:
99 * @tc.type: FUNC
100 * @tc.require: AR000GGNV3
101 * @tc.author:
102 */
103 HWTEST_F(PenTest, CreateByRGBA001, TestSize.Level1)
104 {
105 auto pen = std::make_unique<Pen>(255);
106 ASSERT_TRUE(pen != nullptr);
107 }
108
109 /**
110 * @tc.name: CreateByRGBA002
111 * @tc.desc:
112 * @tc.type: FUNC
113 * @tc.require: AR000GGNV3
114 * @tc.author:
115 */
116 HWTEST_F(PenTest, CreateByRGBA002, TestSize.Level1)
117 {
118 auto pen = std::make_unique<Pen>(100);
119 ASSERT_TRUE(pen != nullptr);
120 }
121
122 /**
123 * @tc.name: GetterAndSetterOfColor001
124 * @tc.desc:
125 * @tc.type: FUNC
126 * @tc.require: AR000GGNV3
127 * @tc.author:
128 */
129 HWTEST_F(PenTest, GetterAndSetterOfColor001, TestSize.Level1)
130 {
131 auto pen = std::make_unique<Pen>();
132 ASSERT_TRUE(pen != nullptr);
133 Color color;
134 pen->SetColor(color);
135 auto colorNew = pen->GetColor();
136 EXPECT_TRUE(color == colorNew);
137 }
138
139 /**
140 * @tc.name: GetterAndSetterOfColor002
141 * @tc.desc:
142 * @tc.type: FUNC
143 * @tc.require: AR000GGNV3
144 * @tc.author:
145 */
146 HWTEST_F(PenTest, GetterAndSetterOfColor002, TestSize.Level1)
147 {
148 auto pen = std::make_unique<Pen>();
149 ASSERT_TRUE(pen != nullptr);
150 Color color = Color(11, 12, 13, 14);
151 pen->SetColor(color);
152 auto colorNew = pen->GetColor();
153 EXPECT_TRUE(color == colorNew);
154 }
155
156 /**
157 * @tc.name: SetColor001
158 * @tc.desc:
159 * @tc.type: FUNC
160 * @tc.require: AR000GGNV3
161 * @tc.author:
162 */
163 HWTEST_F(PenTest, SetColor001, TestSize.Level1)
164 {
165 auto pen = std::make_unique<Pen>();
166 ASSERT_TRUE(pen != nullptr);
167 pen->SetColor(255); // color value
168 }
169
170 /**
171 * @tc.name: SetColor002
172 * @tc.desc:
173 * @tc.type: FUNC
174 * @tc.require: AR000GGNV3
175 * @tc.author:
176 */
177 HWTEST_F(PenTest, SetColor002, TestSize.Level1)
178 {
179 auto pen = std::make_unique<Pen>();
180 ASSERT_TRUE(pen != nullptr);
181 pen->SetColor(100); // color value
182 }
183
184 /**
185 * @tc.name: SetARGB001
186 * @tc.desc:
187 * @tc.type: FUNC
188 * @tc.require: AR000GGNV3
189 * @tc.author:
190 */
191 HWTEST_F(PenTest, SetARGB001, TestSize.Level1)
192 {
193 auto pen = std::make_unique<Pen>();
194 ASSERT_TRUE(pen != nullptr);
195 pen->SetARGB(100, 100, 10, 1); // color value
196 }
197
198 /**
199 * @tc.name: SetARGB002
200 * @tc.desc:
201 * @tc.type: FUNC
202 * @tc.require: AR000GGNV3
203 * @tc.author:
204 */
205 HWTEST_F(PenTest, SetARGB002, TestSize.Level1)
206 {
207 auto pen = std::make_unique<Pen>(11);
208 ASSERT_TRUE(pen != nullptr);
209 pen->SetARGB(100, 2, 10, 0); // color value
210 }
211
212 /**
213 * @tc.name: GetColor4f001
214 * @tc.desc:
215 * @tc.type: FUNC
216 * @tc.require: AR000GGNV3
217 * @tc.author:
218 */
219 HWTEST_F(PenTest, GetColor4f001, TestSize.Level1)
220 {
221 auto pen = std::make_unique<Pen>();
222 ASSERT_TRUE(pen != nullptr);
223 auto colorSpace = std::make_shared<ColorSpace>(ColorSpace::ColorSpaceType::NO_TYPE);
224 Color4f color4f = { 1.5f, 2.5f, 3.5f, 4.5f };
225 pen->SetColor(color4f, colorSpace);
226 Color4f expectColor4f = { 1.0f, 1.0f, 1.0f, 1.0f };
227 EXPECT_TRUE(std::abs(expectColor4f.redF_ - pen->GetColor4f().redF_) < 0.01);
228 EXPECT_TRUE(std::abs(expectColor4f.greenF_ - pen->GetColor4f().greenF_) < 0.01);
229 EXPECT_TRUE(std::abs(expectColor4f.blueF_ - pen->GetColor4f().blueF_) < 0.01);
230 EXPECT_TRUE(std::abs(expectColor4f.alphaF_ - pen->GetColor4f().alphaF_) < 0.01);
231 }
232
233 /**
234 * @tc.name: GetColor4f002
235 * @tc.desc:
236 * @tc.type: FUNC
237 * @tc.require: AR000GGNV3
238 * @tc.author:
239 */
240 HWTEST_F(PenTest, GetColor4f002, TestSize.Level1)
241 {
242 auto pen = std::make_unique<Pen>();
243 ASSERT_TRUE(pen != nullptr);
244 auto colorSpace = std::make_shared<ColorSpace>(ColorSpace::ColorSpaceType::SRGB);
245 Color4f color4f = { -10.5f, -20.5f, -30.5f, -40.5f };
246 pen->SetColor(color4f, colorSpace);
247 Color4f expectColor4f = { 0.0f, 0.0f, 0.0f, 0.0f };
248 EXPECT_TRUE(std::abs(expectColor4f.redF_ - pen->GetColor4f().redF_) < 0.01);
249 EXPECT_TRUE(std::abs(expectColor4f.greenF_ - pen->GetColor4f().greenF_) < 0.01);
250 EXPECT_TRUE(std::abs(expectColor4f.blueF_ - pen->GetColor4f().blueF_) < 0.01);
251 EXPECT_TRUE(std::abs(expectColor4f.alphaF_ - pen->GetColor4f().alphaF_) < 0.01);
252 }
253
254 /**
255 * @tc.name: GetColor4f003
256 * @tc.desc:
257 * @tc.type: FUNC
258 * @tc.require: AR000GGNV3
259 * @tc.author:
260 */
261 HWTEST_F(PenTest, GetColor4f003, TestSize.Level1)
262 {
263 auto pen = std::make_unique<Pen>();
264 ASSERT_TRUE(pen != nullptr);
265 auto colorSpace = std::make_shared<ColorSpace>(ColorSpace::ColorSpaceType::SRGB);
266 Color4f color4f = { 0.3f, 0.4f, 0.5f, 0.6f };
267 pen->SetColor(color4f, colorSpace);
268 Color4f expectColor4f = { 0.3f, 0.4f, 0.5f, 0.6f };
269 EXPECT_TRUE(std::abs(expectColor4f.redF_ - pen->GetColor4f().redF_) < 0.01);
270 EXPECT_TRUE(std::abs(expectColor4f.greenF_ - pen->GetColor4f().greenF_) < 0.01);
271 EXPECT_TRUE(std::abs(expectColor4f.blueF_ - pen->GetColor4f().blueF_) < 0.01);
272 EXPECT_TRUE(std::abs(expectColor4f.alphaF_ - pen->GetColor4f().alphaF_) < 0.01);
273 }
274
275 /**
276 * @tc.name: GetColorSpace001
277 * @tc.desc:
278 * @tc.type: FUNC
279 * @tc.require: AR000GGNV3
280 * @tc.author:
281 */
282 HWTEST_F(PenTest, GetColorSpace001, TestSize.Level1)
283 {
284 auto pen = std::make_unique<Pen>();
285 ASSERT_TRUE(pen != nullptr);
286 auto colorSpace = std::make_shared<ColorSpace>(ColorSpace::ColorSpaceType::SRGB_LINEAR);
287 Color4f color4f;
288 pen->SetColor(color4f, colorSpace);
289 ASSERT_EQ(colorSpace, pen->GetColorSpace());
290 }
291
292 /**
293 * @tc.name: GetColorSpace002
294 * @tc.desc:
295 * @tc.type: FUNC
296 * @tc.require: AR000GGNV3
297 * @tc.author:
298 */
299 HWTEST_F(PenTest, GetColorSpace002, TestSize.Level1)
300 {
301 auto pen = std::make_unique<Pen>();
302 ASSERT_TRUE(pen != nullptr);
303 auto colorSpace = std::make_shared<ColorSpace>(ColorSpace::ColorSpaceType::SRGB);
304 Color4f color4f;
305 pen->SetColor(color4f, colorSpace);
306 ASSERT_EQ(colorSpace, pen->GetColorSpace());
307 }
308
309 /**
310 * @tc.name: SetColorWith2001
311 * @tc.desc:
312 * @tc.type: FUNC
313 * @tc.require: AR000GGNV3
314 * @tc.author:
315 */
316 HWTEST_F(PenTest, SetColorWith2001, TestSize.Level1)
317 {
318 auto pen = std::make_unique<Pen>();
319 ASSERT_TRUE(pen != nullptr);
320 Color4f color4f;
321 auto colorSpace = std::make_shared<ColorSpace>(ColorSpace::ColorSpaceType::SRGB);
322 ASSERT_TRUE(colorSpace != nullptr);
323 pen->SetColor(color4f, colorSpace);
324 }
325
326 /**
327 * @tc.name: SetColorWith2002
328 * @tc.desc:
329 * @tc.type: FUNC
330 * @tc.require: AR000GGNV3
331 * @tc.author:
332 */
333 HWTEST_F(PenTest, SetColorWith2002, TestSize.Level1)
334 {
335 auto pen = std::make_unique<Pen>();
336 ASSERT_TRUE(pen != nullptr);
337 Color4f color4f;
338 auto colorSpace = std::make_shared<ColorSpace>(ColorSpace::ColorSpaceType::REF_IMAGE);
339 ASSERT_TRUE(colorSpace != nullptr);
340 pen->SetColor(color4f, colorSpace);
341 }
342
343 /**
344 * @tc.name: GetterAndSetterOfAlpha001
345 * @tc.desc:
346 * @tc.type: FUNC
347 * @tc.require: AR000GGNV3
348 * @tc.author:
349 */
350 HWTEST_F(PenTest, GetterAndSetterOfAlpha001, TestSize.Level1)
351 {
352 auto pen = std::make_unique<Pen>();
353 ASSERT_TRUE(pen != nullptr);
354 uint32_t alpha = 1;
355 pen->SetAlpha(alpha);
356 ASSERT_EQ(alpha, pen->GetAlpha());
357 }
358
359 /**
360 * @tc.name: GetterAndSetterOfAlpha002
361 * @tc.desc:
362 * @tc.type: FUNC
363 * @tc.require: AR000GGNV3
364 * @tc.author:
365 */
366 HWTEST_F(PenTest, GetterAndSetterOfAlpha002, TestSize.Level1)
367 {
368 auto pen = std::make_unique<Pen>();
369 ASSERT_TRUE(pen != nullptr);
370 uint32_t alpha = 0;
371 pen->SetAlpha(alpha);
372 ASSERT_EQ(alpha, pen->GetAlpha());
373 }
374
375 /**
376 * @tc.name: GetterAndSetterOfAlphaf001
377 * @tc.desc:
378 * @tc.type: FUNC
379 * @tc.require: AR000GGNV3
380 * @tc.author:
381 */
382 HWTEST_F(PenTest, GetterAndSetterOfAlphaf001, TestSize.Level1)
383 {
384 auto pen = std::make_unique<Pen>();
385 ASSERT_TRUE(pen != nullptr);
386 scalar alpha = 0;
387 pen->SetAlphaF(alpha);
388 ASSERT_TRUE(IsScalarAlmostEqual(alpha, pen->GetAlphaF()));
389 }
390
391 /**
392 * @tc.name: GetterAndSetterOfWidth001
393 * @tc.desc:
394 * @tc.type: FUNC
395 * @tc.require: AR000GGNV3
396 * @tc.author:
397 */
398 HWTEST_F(PenTest, GetterAndSetterOfWidth001, TestSize.Level1)
399 {
400 auto pen = std::make_unique<Pen>();
401 ASSERT_TRUE(pen != nullptr);
402 scalar w = 0;
403 pen->SetWidth(w);
404 ASSERT_TRUE(IsScalarAlmostEqual(w, pen->GetWidth()));
405 }
406
407 /**
408 * @tc.name: SetAlphaF001
409 * @tc.desc:
410 * @tc.type: FUNC
411 * @tc.require: AR000GGNV3
412 * @tc.author:
413 */
414 HWTEST_F(PenTest, SetAlphaF001, TestSize.Level1)
415 {
416 auto pen = std::make_unique<Pen>();
417 ASSERT_TRUE(pen != nullptr);
418 pen->SetAlphaF(0.5f);
419 }
420
421 /**
422 * @tc.name: SetAlphaF002
423 * @tc.desc:
424 * @tc.type: FUNC
425 * @tc.require: AR000GGNV3
426 * @tc.author:
427 */
428 HWTEST_F(PenTest, SetAlphaF002, TestSize.Level1)
429 {
430 auto pen = std::make_unique<Pen>();
431 ASSERT_TRUE(pen != nullptr);
432 pen->SetAlphaF(15.0f);
433 }
434
435 /**
436 * @tc.name: GetterAndSetterOfMiterLimit001
437 * @tc.desc:
438 * @tc.type: FUNC
439 * @tc.require: AR000GGNV3
440 * @tc.author:
441 */
442 HWTEST_F(PenTest, GetterAndSetterOfMiterLimit001, TestSize.Level1)
443 {
444 auto pen = std::make_unique<Pen>();
445 ASSERT_TRUE(pen != nullptr);
446 pen->SetMiterLimit(100.0f);
447 auto limit = pen->GetMiterLimit();
448 ASSERT_EQ(limit, 100.0f);
449 }
450
451 /**
452 * @tc.name: GetterAndSetterOfMiterLimit002
453 * @tc.desc:
454 * @tc.type: FUNC
455 * @tc.require: AR000GGNV3
456 * @tc.author:
457 */
458 HWTEST_F(PenTest, GetterAndSetterOfMiterLimit002, TestSize.Level1)
459 {
460 auto pen = std::make_unique<Pen>();
461 ASSERT_TRUE(pen != nullptr);
462 pen->SetMiterLimit(20.5f);
463 auto limit = pen->GetMiterLimit();
464 ASSERT_EQ(limit, 20.5f);
465 }
466
467 /**
468 * @tc.name: GetterAndSetterOfCapStyle001
469 * @tc.desc:
470 * @tc.type: FUNC
471 * @tc.require: AR000GGNV3
472 * @tc.author:
473 */
474 HWTEST_F(PenTest, GetterAndSetterOfCapStyle001, TestSize.Level1)
475 {
476 auto pen = std::make_unique<Pen>();
477 ASSERT_TRUE(pen != nullptr);
478 pen->SetCapStyle(Pen::CapStyle::FLAT_CAP);
479 ASSERT_EQ(Pen::CapStyle::FLAT_CAP, pen->GetCapStyle());
480 }
481
482 /**
483 * @tc.name: GetterAndSetterOfCapStyle002
484 * @tc.desc:
485 * @tc.type: FUNC
486 * @tc.require: AR000GGNV3
487 * @tc.author:
488 */
489 HWTEST_F(PenTest, GetterAndSetterOfCapStyle002, TestSize.Level1)
490 {
491 auto pen = std::make_unique<Pen>();
492 ASSERT_TRUE(pen != nullptr);
493 pen->SetCapStyle(Pen::CapStyle::ROUND_CAP);
494 ASSERT_EQ(Pen::CapStyle::ROUND_CAP, pen->GetCapStyle());
495 }
496
497 /**
498 * @tc.name: GetterAndSetterOfJoinStyle001
499 * @tc.desc:
500 * @tc.type: FUNC
501 * @tc.require: AR000GGNV3
502 * @tc.author:
503 */
504 HWTEST_F(PenTest, GetterAndSetterOfJoinStyle001, TestSize.Level1)
505 {
506 auto pen = std::make_unique<Pen>();
507 ASSERT_TRUE(pen != nullptr);
508 pen->SetJoinStyle(Pen::JoinStyle::ROUND_JOIN);
509 ASSERT_EQ(Pen::JoinStyle::ROUND_JOIN, pen->GetJoinStyle());
510 }
511
512 /**
513 * @tc.name: GetterAndSetterOfJoinStyle002
514 * @tc.desc:
515 * @tc.type: FUNC
516 * @tc.require: AR000GGNV3
517 * @tc.author:
518 */
519 HWTEST_F(PenTest, GetterAndSetterOfJoinStyle002, TestSize.Level1)
520 {
521 auto pen = std::make_unique<Pen>();
522 ASSERT_TRUE(pen != nullptr);
523 pen->SetJoinStyle(Pen::JoinStyle::BEVEL_JOIN);
524 ASSERT_EQ(Pen::JoinStyle::BEVEL_JOIN, pen->GetJoinStyle());
525 }
526
527 /**
528 * @tc.name: GetterAndSetterOfBlendMode001
529 * @tc.desc:
530 * @tc.type: FUNC
531 * @tc.require: AR000GGNV3
532 * @tc.author:
533 */
534 HWTEST_F(PenTest, GetterAndSetterOfBlendMode001, TestSize.Level1)
535 {
536 auto pen = std::make_unique<Pen>();
537 ASSERT_TRUE(pen != nullptr);
538 pen->SetBlendMode(BlendMode::SRC_IN);
539 ASSERT_EQ(BlendMode::SRC_IN, pen->GetBlendMode());
540 }
541
542 /**
543 * @tc.name: GetterAndSetterOfBlendMode002
544 * @tc.desc:
545 * @tc.type: FUNC
546 * @tc.require: AR000GGNV3
547 * @tc.author:
548 */
549 HWTEST_F(PenTest, GetterAndSetterOfBlendMode002, TestSize.Level1)
550 {
551 auto pen = std::make_unique<Pen>();
552 ASSERT_TRUE(pen != nullptr);
553 pen->SetBlendMode(BlendMode::SRC_ATOP);
554 ASSERT_EQ(BlendMode::SRC_ATOP, pen->GetBlendMode());
555 }
556
557 /**
558 * @tc.name: GetterAndSetterOfBlender001
559 * @tc.desc:
560 * @tc.type: FUNC
561 * @tc.require: AR000GGNV3
562 * @tc.author:
563 */
564 HWTEST_F(PenTest, GetterAndSetterOfBlender001, TestSize.Level1)
565 {
566 auto pen = std::make_unique<Pen>();
567 ASSERT_TRUE(pen != nullptr);
568 std::shared_ptr<Blender> blender = std::make_unique<Blender>();
569 pen->SetBlender(blender);
570 ASSERT_EQ(blender, pen->GetBlender());
571 }
572
573 /**
574 * @tc.name: GetterAndSetterOfBlenderEnabled001
575 * @tc.desc:
576 * @tc.type: FUNC
577 * @tc.require: AR000GGNV3
578 * @tc.author:
579 */
580 HWTEST_F(PenTest, GetterAndSetterOfBlenderEnabled001, TestSize.Level1)
581 {
582 auto pen = std::make_unique<Pen>();
583 ASSERT_TRUE(pen != nullptr);
584 pen->SetBlenderEnabled(true);
585 auto result = pen->GetBlenderEnabled();
586 EXPECT_TRUE(result == true);
587 }
588
589 /**
590 * @tc.name: GetterAndSetterOfBlenderEnabled002
591 * @tc.desc:
592 * @tc.type: FUNC
593 * @tc.require: AR000GGNV3
594 * @tc.author:
595 */
596 HWTEST_F(PenTest, GetterAndSetterOfBlenderEnabled002, TestSize.Level1)
597 {
598 auto pen = std::make_unique<Pen>();
599 ASSERT_TRUE(pen != nullptr);
600 pen->SetBlenderEnabled(false);
601 auto result = pen->GetBlenderEnabled();
602 EXPECT_TRUE(result == false);
603 }
604
605 /**
606 * @tc.name: GetterAndSetterOfAntiAlias001
607 * @tc.desc:
608 * @tc.type: FUNC
609 * @tc.require: AR000GGNV3
610 * @tc.author:
611 */
612 HWTEST_F(PenTest, GetterAndSetterOfAntiAlias001, TestSize.Level1)
613 {
614 auto pen = std::make_unique<Pen>();
615 ASSERT_TRUE(pen != nullptr);
616 pen->SetAntiAlias(true);
617 auto result = pen->IsAntiAlias();
618 EXPECT_TRUE(result == true);
619 }
620
621 /**
622 * @tc.name: GetterAndSetterOfAntiAlias002
623 * @tc.desc:
624 * @tc.type: FUNC
625 * @tc.require: AR000GGNV3
626 * @tc.author:
627 */
628 HWTEST_F(PenTest, GetterAndSetterOfAntiAlias002, TestSize.Level1)
629 {
630 auto pen = std::make_unique<Pen>();
631 ASSERT_TRUE(pen != nullptr);
632 pen->SetAntiAlias(false);
633 auto result = pen->IsAntiAlias();
634 EXPECT_TRUE(result == false);
635 }
636
637 /**
638 * @tc.name: GetterAndSetterOfPathEffect001
639 * @tc.desc:
640 * @tc.type: FUNC
641 * @tc.require: AR000GGNV3
642 * @tc.author:
643 */
644 HWTEST_F(PenTest, GetterAndSetterOfPathEffect001, TestSize.Level1)
645 {
646 auto pen = std::make_unique<Pen>();
647 ASSERT_TRUE(pen != nullptr);
648 auto pathEffect = std::make_shared<PathEffect>(PathEffect::PathEffectType::DASH, 0.2f);
649 ASSERT_TRUE(pathEffect != nullptr);
650 pen->SetPathEffect(pathEffect);
651 auto result = pen->GetPathEffect();
652 EXPECT_TRUE(result == pathEffect);
653 }
654
655 /**
656 * @tc.name: GetterAndSetterOfPathEffect002
657 * @tc.desc:
658 * @tc.type: FUNC
659 * @tc.require: AR000GGNV3
660 * @tc.author:
661 */
662 HWTEST_F(PenTest, GetterAndSetterOfPathEffect002, TestSize.Level1)
663 {
664 auto pen = std::make_unique<Pen>();
665 ASSERT_TRUE(pen != nullptr);
666 auto pathEffect = std::make_shared<PathEffect>(PathEffect::PathEffectType::COMPOSE, 0.1f);
667 ASSERT_TRUE(pathEffect != nullptr);
668 pen->SetPathEffect(pathEffect);
669 auto result = pen->GetPathEffect();
670 EXPECT_TRUE(result == pathEffect);
671 }
672
673 /**
674 * @tc.name: GetterAndSetterOfFilter001
675 * @tc.desc:
676 * @tc.type: FUNC
677 * @tc.require: AR000GGNV3
678 * @tc.author:
679 */
680 HWTEST_F(PenTest, GetterAndSetterOfFilter001, TestSize.Level1)
681 {
682 auto pen = std::make_unique<Pen>();
683 ASSERT_TRUE(pen != nullptr);
684 Filter filter;
685 pen->SetFilter(filter);
686 auto result = pen->GetFilter();
687 EXPECT_EQ(result, filter);
688 EXPECT_TRUE(pen->HasFilter());
689 }
690
691 /**
692 * @tc.name: GetterAndSetterOfFilter002
693 * @tc.desc:
694 * @tc.type: FUNC
695 * @tc.require: AR000GGNV3
696 * @tc.author:
697 */
698 HWTEST_F(PenTest, GetterAndSetterOfFilter002, TestSize.Level1)
699 {
700 auto pen = std::make_unique<Pen>(255);
701 ASSERT_TRUE(pen != nullptr);
702 Filter filter;
703 pen->SetFilter(filter);
704 auto result = pen->GetFilter();
705 EXPECT_EQ(result, filter);
706 EXPECT_TRUE(pen->HasFilter());
707 }
708
709 /**
710 * @tc.name: GetterAndSetterOfShaderEffect001
711 * @tc.desc:
712 * @tc.type: FUNC
713 * @tc.require: AR000GGNV3
714 * @tc.author:
715 */
716 HWTEST_F(PenTest, GetterAndSetterOfShaderEffect001, TestSize.Level1)
717 {
718 auto pen = std::make_unique<Pen>();
719 ASSERT_TRUE(pen != nullptr);
720 auto shaderEffect = ShaderEffect::CreateColorShader(1);
721 ASSERT_TRUE(shaderEffect != nullptr);
722 pen->SetShaderEffect(shaderEffect);
723 auto result = pen->GetShaderEffect();
724 EXPECT_EQ(result, shaderEffect);
725 }
726
727 /**
728 * @tc.name: GetterAndSetterOfPathEffect003
729 * @tc.desc:
730 * @tc.type: FUNC
731 * @tc.require: AR000GGNV3
732 * @tc.author:
733 */
734 HWTEST_F(PenTest, GetterAndSetterOfPathEffect003, TestSize.Level1)
735 {
736 auto pen = std::make_unique<Pen>();
737 ASSERT_TRUE(pen != nullptr);
738 auto pathEffect = std::make_shared<PathEffect>(PathEffect::PathEffectType::NO_TYPE, 0.5f);
739 ASSERT_TRUE(pathEffect != nullptr);
740 pen->SetPathEffect(pathEffect);
741 auto result = pen->GetPathEffect();
742 EXPECT_EQ(result, pathEffect);
743 pen->Reset();
744 }
745
746 /**
747 * @tc.name: GetterAndSetterOfPathEffect004
748 * @tc.desc:
749 * @tc.type: FUNC
750 * @tc.require: AR000GGNV3
751 * @tc.author:
752 */
753 HWTEST_F(PenTest, GetterAndSetterOfPathEffect004, TestSize.Level1)
754 {
755 auto pen = std::make_unique<Pen>();
756 ASSERT_TRUE(pen != nullptr);
757 auto pathEffect = std::make_shared<PathEffect>(PathEffect::PathEffectType::CORNER, 0.2f);
758 ASSERT_TRUE(pathEffect != nullptr);
759 pen->SetPathEffect(pathEffect);
760 auto result = pen->GetPathEffect();
761 EXPECT_EQ(result, pathEffect);
762 pen->Reset();
763 }
764
765 /**
766 * @tc.name: OverrideEquals001
767 * @tc.desc:
768 * @tc.type: FUNC
769 * @tc.require: AR000GGNV3
770 * @tc.author:
771 */
772 HWTEST_F(PenTest, OverrideEquals001, TestSize.Level1)
773 {
774 Pen pen1;
775 Pen pen2 = Pen(255);
776 EXPECT_FALSE(pen1 == pen2);
777 }
778
779 /**
780 * @tc.name: OverrideEquals002
781 * @tc.desc:
782 * @tc.type: FUNC
783 * @tc.require: AR000GGNV3
784 * @tc.author:
785 */
786 HWTEST_F(PenTest, OverrideEquals002, TestSize.Level1)
787 {
788 Pen pen1;
789 Pen pen2 = pen1;
790 EXPECT_TRUE(pen1 == pen2);
791 }
792
793 /**
794 * @tc.name: OverrideEquals003
795 * @tc.desc:
796 * @tc.type: FUNC
797 * @tc.require: AR20240104201189
798 * @tc.author:
799 */
800 HWTEST_F(PenTest, OverrideEquals003, TestSize.Level1)
801 {
802 Pen pen1;
803 // 1.f 2.f 3.f and 0x12345678 is setted to compare.
804 float radius = 1.f;
805 Point point{2.f, 3.f};
806 Color color = Color(0x12345678);
807 std::shared_ptr<BlurDrawLooper> blurDrawLooper = BlurDrawLooper::CreateBlurDrawLooper(radius,
808 point.GetX(), point.GetY(), color);
809 pen1.SetLooper(blurDrawLooper);
810 Pen pen2 = pen1;
811 EXPECT_TRUE(pen1 == pen2);
812 pen2.SetLooper(nullptr);
813 EXPECT_TRUE(pen1 != pen2);
814 }
815
816 /**
817 * @tc.name: OverrideNotEquals001
818 * @tc.desc:
819 * @tc.type: FUNC
820 * @tc.require: AR000GGNV3
821 * @tc.author:
822 */
823 HWTEST_F(PenTest, OverrideNotEquals001, TestSize.Level1)
824 {
825 Pen pen1;
826 Pen pen2 = Pen(255);
827 EXPECT_TRUE(pen1 != pen2);
828 }
829
830 /**
831 * @tc.name: OverrideNotEquals002
832 * @tc.desc:
833 * @tc.type: FUNC
834 * @tc.require: AR000GGNV3
835 * @tc.author:
836 */
837 HWTEST_F(PenTest, OverrideNotEquals002, TestSize.Level1)
838 {
839 Pen pen1 = Pen(128);
840 Pen pen2 = Pen(0);
841 EXPECT_TRUE(pen1 != pen2);
842 }
843
844 /**
845 * @tc.name: SetLoop001
846 * @tc.desc: Test for SetLooper
847 * @tc.type: FUNC
848 * @tc.require: AR000GGNV3
849 * @tc.author:
850 */
851 HWTEST_F(PenTest, SetLoop001, TestSize.Level1)
852 {
853 Pen pen;
854 auto looper = BlurDrawLooper::CreateBlurDrawLooper(1.0, 1, 1, Color::COLOR_BLACK);
855 pen.SetLooper(looper);
856 EXPECT_TRUE(looper == pen.GetLooper());
857 }
858
859 /**
860 * @tc.name: GetFillPath001
861 * @tc.desc: Test for GetFillPath
862 * @tc.type: FUNC
863 * @tc.require: AR000GGNV3
864 * @tc.author:
865 */
866 HWTEST_F(PenTest, GetFillPath001, TestSize.Level1)
867 {
868 Pen pen;
869 pen.SetWidth(10);
870 pen.SetPathEffect(PathEffect::CreateCornerPathEffect(10));
871 Path srcPath;
872 Path dstPath;
873 srcPath.LineTo(100, 100); // 100: x, y
874 Rect rect(0, 0, 100, 100); // 100: right, bottom
875 Matrix matrix;
876 bool ret = false;
877 ret = pen.GetFillPath(srcPath, dstPath, &rect, matrix);
878 EXPECT_TRUE(ret);
879 ret = pen.GetFillPath(srcPath, dstPath, nullptr, matrix);
880 EXPECT_TRUE(ret);
881 }
882 } // namespace Drawing
883 } // namespace Rosen
884 } // namespace OHOS
885