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 auto pen = std::make_unique<Pen>(oldPen);
63 ASSERT_TRUE(pen != nullptr);
64 }
65
66 /**
67 * @tc.name: CreateByColor001
68 * @tc.desc:
69 * @tc.type: FUNC
70 * @tc.require: AR000GGNV3
71 * @tc.author:
72 */
73 HWTEST_F(PenTest, CreateByColor001, TestSize.Level1)
74 {
75 Color color = Color(255, 255, 255, 255);
76 auto pen = std::make_unique<Pen>(color);
77 ASSERT_TRUE(pen != nullptr);
78 }
79
80 /**
81 * @tc.name: CreateByColor002
82 * @tc.desc:
83 * @tc.type: FUNC
84 * @tc.require: AR000GGNV3
85 * @tc.author:
86 */
87 HWTEST_F(PenTest, CreateByColor002, TestSize.Level1)
88 {
89 Color color = Color(11, 12, 13, 14);
90 auto pen = std::make_unique<Pen>(color);
91 ASSERT_TRUE(pen != nullptr);
92 }
93
94 /**
95 * @tc.name: CreateByRGBA001
96 * @tc.desc:
97 * @tc.type: FUNC
98 * @tc.require: AR000GGNV3
99 * @tc.author:
100 */
101 HWTEST_F(PenTest, CreateByRGBA001, TestSize.Level1)
102 {
103 auto pen = std::make_unique<Pen>(255);
104 ASSERT_TRUE(pen != nullptr);
105 }
106
107 /**
108 * @tc.name: CreateByRGBA002
109 * @tc.desc:
110 * @tc.type: FUNC
111 * @tc.require: AR000GGNV3
112 * @tc.author:
113 */
114 HWTEST_F(PenTest, CreateByRGBA002, TestSize.Level1)
115 {
116 auto pen = std::make_unique<Pen>(100);
117 ASSERT_TRUE(pen != nullptr);
118 }
119
120 /**
121 * @tc.name: GetterAndSetterOfColor001
122 * @tc.desc:
123 * @tc.type: FUNC
124 * @tc.require: AR000GGNV3
125 * @tc.author:
126 */
127 HWTEST_F(PenTest, GetterAndSetterOfColor001, TestSize.Level1)
128 {
129 auto pen = std::make_unique<Pen>();
130 ASSERT_TRUE(pen != nullptr);
131 Color color;
132 pen->SetColor(color);
133 auto colorNew = pen->GetColor();
134 EXPECT_TRUE(color == colorNew);
135 }
136
137 /**
138 * @tc.name: GetterAndSetterOfColor002
139 * @tc.desc:
140 * @tc.type: FUNC
141 * @tc.require: AR000GGNV3
142 * @tc.author:
143 */
144 HWTEST_F(PenTest, GetterAndSetterOfColor002, TestSize.Level1)
145 {
146 auto pen = std::make_unique<Pen>();
147 ASSERT_TRUE(pen != nullptr);
148 Color color = Color(11, 12, 13, 14);
149 pen->SetColor(color);
150 auto colorNew = pen->GetColor();
151 EXPECT_TRUE(color == colorNew);
152 }
153
154 /**
155 * @tc.name: SetColor001
156 * @tc.desc:
157 * @tc.type: FUNC
158 * @tc.require: AR000GGNV3
159 * @tc.author:
160 */
161 HWTEST_F(PenTest, SetColor001, TestSize.Level1)
162 {
163 auto pen = std::make_unique<Pen>();
164 ASSERT_TRUE(pen != nullptr);
165 pen->SetColor(255); // color value
166 }
167
168 /**
169 * @tc.name: SetColor002
170 * @tc.desc:
171 * @tc.type: FUNC
172 * @tc.require: AR000GGNV3
173 * @tc.author:
174 */
175 HWTEST_F(PenTest, SetColor002, TestSize.Level1)
176 {
177 auto pen = std::make_unique<Pen>();
178 ASSERT_TRUE(pen != nullptr);
179 pen->SetColor(100); // color value
180 }
181
182 /**
183 * @tc.name: SetARGB001
184 * @tc.desc:
185 * @tc.type: FUNC
186 * @tc.require: AR000GGNV3
187 * @tc.author:
188 */
189 HWTEST_F(PenTest, SetARGB001, TestSize.Level1)
190 {
191 auto pen = std::make_unique<Pen>();
192 ASSERT_TRUE(pen != nullptr);
193 pen->SetARGB(100, 100, 10, 1); // color value
194 }
195
196 /**
197 * @tc.name: SetARGB002
198 * @tc.desc:
199 * @tc.type: FUNC
200 * @tc.require: AR000GGNV3
201 * @tc.author:
202 */
203 HWTEST_F(PenTest, SetARGB002, TestSize.Level1)
204 {
205 auto pen = std::make_unique<Pen>(11);
206 ASSERT_TRUE(pen != nullptr);
207 pen->SetARGB(100, 2, 10, 0); // color value
208 }
209
210 /**
211 * @tc.name: GetColor4f001
212 * @tc.desc:
213 * @tc.type: FUNC
214 * @tc.require: AR000GGNV3
215 * @tc.author:
216 */
217 HWTEST_F(PenTest, GetColor4f001, TestSize.Level1)
218 {
219 auto pen = std::make_unique<Pen>();
220 ASSERT_TRUE(pen != nullptr);
221 auto colorSpace = std::make_shared<ColorSpace>(ColorSpace::ColorSpaceType::NO_TYPE);
222 Color4f color4f = { 1.5f, 2.5f, 3.5f, 4.5f };
223 pen->SetColor(color4f, colorSpace);
224 Color4f expectColor4f = { 1.0f, 1.0f, 1.0f, 1.0f };
225 EXPECT_TRUE(std::abs(expectColor4f.redF_ - pen->GetColor4f().redF_) < 0.01);
226 EXPECT_TRUE(std::abs(expectColor4f.greenF_ - pen->GetColor4f().greenF_) < 0.01);
227 EXPECT_TRUE(std::abs(expectColor4f.blueF_ - pen->GetColor4f().blueF_) < 0.01);
228 EXPECT_TRUE(std::abs(expectColor4f.alphaF_ - pen->GetColor4f().alphaF_) < 0.01);
229 }
230
231 /**
232 * @tc.name: GetColor4f002
233 * @tc.desc:
234 * @tc.type: FUNC
235 * @tc.require: AR000GGNV3
236 * @tc.author:
237 */
238 HWTEST_F(PenTest, GetColor4f002, TestSize.Level1)
239 {
240 auto pen = std::make_unique<Pen>();
241 ASSERT_TRUE(pen != nullptr);
242 auto colorSpace = std::make_shared<ColorSpace>(ColorSpace::ColorSpaceType::SRGB);
243 Color4f color4f = { -10.5f, -20.5f, -30.5f, -40.5f };
244 pen->SetColor(color4f, colorSpace);
245 Color4f expectColor4f = { 0.0f, 0.0f, 0.0f, 0.0f };
246 EXPECT_TRUE(std::abs(expectColor4f.redF_ - pen->GetColor4f().redF_) < 0.01);
247 EXPECT_TRUE(std::abs(expectColor4f.greenF_ - pen->GetColor4f().greenF_) < 0.01);
248 EXPECT_TRUE(std::abs(expectColor4f.blueF_ - pen->GetColor4f().blueF_) < 0.01);
249 EXPECT_TRUE(std::abs(expectColor4f.alphaF_ - pen->GetColor4f().alphaF_) < 0.01);
250 }
251
252 /**
253 * @tc.name: GetColor4f003
254 * @tc.desc:
255 * @tc.type: FUNC
256 * @tc.require: AR000GGNV3
257 * @tc.author:
258 */
259 HWTEST_F(PenTest, GetColor4f003, TestSize.Level1)
260 {
261 auto pen = std::make_unique<Pen>();
262 ASSERT_TRUE(pen != nullptr);
263 auto colorSpace = std::make_shared<ColorSpace>(ColorSpace::ColorSpaceType::SRGB);
264 Color4f color4f = { 0.3f, 0.4f, 0.5f, 0.6f };
265 pen->SetColor(color4f, colorSpace);
266 Color4f expectColor4f = { 0.3f, 0.4f, 0.5f, 0.6f };
267 EXPECT_TRUE(std::abs(expectColor4f.redF_ - pen->GetColor4f().redF_) < 0.01);
268 EXPECT_TRUE(std::abs(expectColor4f.greenF_ - pen->GetColor4f().greenF_) < 0.01);
269 EXPECT_TRUE(std::abs(expectColor4f.blueF_ - pen->GetColor4f().blueF_) < 0.01);
270 EXPECT_TRUE(std::abs(expectColor4f.alphaF_ - pen->GetColor4f().alphaF_) < 0.01);
271 }
272
273 /**
274 * @tc.name: GetColorSpace001
275 * @tc.desc:
276 * @tc.type: FUNC
277 * @tc.require: AR000GGNV3
278 * @tc.author:
279 */
280 HWTEST_F(PenTest, GetColorSpace001, TestSize.Level1)
281 {
282 auto pen = std::make_unique<Pen>();
283 ASSERT_TRUE(pen != nullptr);
284 auto colorSpace = std::make_shared<ColorSpace>(ColorSpace::ColorSpaceType::SRGB_LINEAR);
285 Color4f color4f;
286 pen->SetColor(color4f, colorSpace);
287 ASSERT_EQ(colorSpace, pen->GetColorSpace());
288 }
289
290 /**
291 * @tc.name: GetColorSpace002
292 * @tc.desc:
293 * @tc.type: FUNC
294 * @tc.require: AR000GGNV3
295 * @tc.author:
296 */
297 HWTEST_F(PenTest, GetColorSpace002, TestSize.Level1)
298 {
299 auto pen = std::make_unique<Pen>();
300 ASSERT_TRUE(pen != nullptr);
301 auto colorSpace = std::make_shared<ColorSpace>(ColorSpace::ColorSpaceType::SRGB);
302 Color4f color4f;
303 pen->SetColor(color4f, colorSpace);
304 ASSERT_EQ(colorSpace, pen->GetColorSpace());
305 }
306
307 /**
308 * @tc.name: SetColorWith2001
309 * @tc.desc:
310 * @tc.type: FUNC
311 * @tc.require: AR000GGNV3
312 * @tc.author:
313 */
314 HWTEST_F(PenTest, SetColorWith2001, TestSize.Level1)
315 {
316 auto pen = std::make_unique<Pen>();
317 ASSERT_TRUE(pen != nullptr);
318 Color4f color4f;
319 auto colorSpace = std::make_shared<ColorSpace>(ColorSpace::ColorSpaceType::SRGB);
320 ASSERT_TRUE(colorSpace != nullptr);
321 pen->SetColor(color4f, colorSpace);
322 }
323
324 /**
325 * @tc.name: SetColorWith2002
326 * @tc.desc:
327 * @tc.type: FUNC
328 * @tc.require: AR000GGNV3
329 * @tc.author:
330 */
331 HWTEST_F(PenTest, SetColorWith2002, TestSize.Level1)
332 {
333 auto pen = std::make_unique<Pen>();
334 ASSERT_TRUE(pen != nullptr);
335 Color4f color4f;
336 auto colorSpace = std::make_shared<ColorSpace>(ColorSpace::ColorSpaceType::REF_IMAGE);
337 ASSERT_TRUE(colorSpace != nullptr);
338 pen->SetColor(color4f, colorSpace);
339 }
340
341 /**
342 * @tc.name: GetterAndSetterOfAlpha001
343 * @tc.desc:
344 * @tc.type: FUNC
345 * @tc.require: AR000GGNV3
346 * @tc.author:
347 */
348 HWTEST_F(PenTest, GetterAndSetterOfAlpha001, TestSize.Level1)
349 {
350 auto pen = std::make_unique<Pen>();
351 ASSERT_TRUE(pen != nullptr);
352 uint32_t alpha = 1;
353 pen->SetAlpha(alpha);
354 ASSERT_EQ(alpha, pen->GetAlpha());
355 }
356
357 /**
358 * @tc.name: GetterAndSetterOfAlpha002
359 * @tc.desc:
360 * @tc.type: FUNC
361 * @tc.require: AR000GGNV3
362 * @tc.author:
363 */
364 HWTEST_F(PenTest, GetterAndSetterOfAlpha002, TestSize.Level1)
365 {
366 auto pen = std::make_unique<Pen>();
367 ASSERT_TRUE(pen != nullptr);
368 uint32_t alpha = 0;
369 pen->SetAlpha(alpha);
370 ASSERT_EQ(alpha, pen->GetAlpha());
371 }
372
373 /**
374 * @tc.name: SetAlphaF001
375 * @tc.desc:
376 * @tc.type: FUNC
377 * @tc.require: AR000GGNV3
378 * @tc.author:
379 */
380 HWTEST_F(PenTest, SetAlphaF001, TestSize.Level1)
381 {
382 auto pen = std::make_unique<Pen>();
383 ASSERT_TRUE(pen != nullptr);
384 pen->SetAlphaF(0.5f);
385 }
386
387 /**
388 * @tc.name: SetAlphaF002
389 * @tc.desc:
390 * @tc.type: FUNC
391 * @tc.require: AR000GGNV3
392 * @tc.author:
393 */
394 HWTEST_F(PenTest, SetAlphaF002, TestSize.Level1)
395 {
396 auto pen = std::make_unique<Pen>();
397 ASSERT_TRUE(pen != nullptr);
398 pen->SetAlphaF(15.0f);
399 }
400
401 /**
402 * @tc.name: GetterAndSetterOfMiterLimit001
403 * @tc.desc:
404 * @tc.type: FUNC
405 * @tc.require: AR000GGNV3
406 * @tc.author:
407 */
408 HWTEST_F(PenTest, GetterAndSetterOfMiterLimit001, TestSize.Level1)
409 {
410 auto pen = std::make_unique<Pen>();
411 ASSERT_TRUE(pen != nullptr);
412 pen->SetMiterLimit(100.0f);
413 auto limit = pen->GetMiterLimit();
414 ASSERT_EQ(limit, 100.0f);
415 }
416
417 /**
418 * @tc.name: GetterAndSetterOfMiterLimit002
419 * @tc.desc:
420 * @tc.type: FUNC
421 * @tc.require: AR000GGNV3
422 * @tc.author:
423 */
424 HWTEST_F(PenTest, GetterAndSetterOfMiterLimit002, TestSize.Level1)
425 {
426 auto pen = std::make_unique<Pen>();
427 ASSERT_TRUE(pen != nullptr);
428 pen->SetMiterLimit(20.5f);
429 auto limit = pen->GetMiterLimit();
430 ASSERT_EQ(limit, 20.5f);
431 }
432
433 /**
434 * @tc.name: GetterAndSetterOfCapStyle001
435 * @tc.desc:
436 * @tc.type: FUNC
437 * @tc.require: AR000GGNV3
438 * @tc.author:
439 */
440 HWTEST_F(PenTest, GetterAndSetterOfCapStyle001, TestSize.Level1)
441 {
442 auto pen = std::make_unique<Pen>();
443 ASSERT_TRUE(pen != nullptr);
444 pen->SetCapStyle(Pen::CapStyle::FLAT_CAP);
445 ASSERT_EQ(Pen::CapStyle::FLAT_CAP, pen->GetCapStyle());
446 }
447
448 /**
449 * @tc.name: GetterAndSetterOfCapStyle002
450 * @tc.desc:
451 * @tc.type: FUNC
452 * @tc.require: AR000GGNV3
453 * @tc.author:
454 */
455 HWTEST_F(PenTest, GetterAndSetterOfCapStyle002, TestSize.Level1)
456 {
457 auto pen = std::make_unique<Pen>();
458 ASSERT_TRUE(pen != nullptr);
459 pen->SetCapStyle(Pen::CapStyle::ROUND_CAP);
460 ASSERT_EQ(Pen::CapStyle::ROUND_CAP, pen->GetCapStyle());
461 }
462
463 /**
464 * @tc.name: GetterAndSetterOfJoinStyle001
465 * @tc.desc:
466 * @tc.type: FUNC
467 * @tc.require: AR000GGNV3
468 * @tc.author:
469 */
470 HWTEST_F(PenTest, GetterAndSetterOfJoinStyle001, TestSize.Level1)
471 {
472 auto pen = std::make_unique<Pen>();
473 ASSERT_TRUE(pen != nullptr);
474 pen->SetJoinStyle(Pen::JoinStyle::ROUND_JOIN);
475 ASSERT_EQ(Pen::JoinStyle::ROUND_JOIN, pen->GetJoinStyle());
476 }
477
478 /**
479 * @tc.name: GetterAndSetterOfJoinStyle002
480 * @tc.desc:
481 * @tc.type: FUNC
482 * @tc.require: AR000GGNV3
483 * @tc.author:
484 */
485 HWTEST_F(PenTest, GetterAndSetterOfJoinStyle002, TestSize.Level1)
486 {
487 auto pen = std::make_unique<Pen>();
488 ASSERT_TRUE(pen != nullptr);
489 pen->SetJoinStyle(Pen::JoinStyle::BEVEL_JOIN);
490 ASSERT_EQ(Pen::JoinStyle::BEVEL_JOIN, pen->GetJoinStyle());
491 }
492
493 /**
494 * @tc.name: GetterAndSetterOfBlendMode001
495 * @tc.desc:
496 * @tc.type: FUNC
497 * @tc.require: AR000GGNV3
498 * @tc.author:
499 */
500 HWTEST_F(PenTest, GetterAndSetterOfBlendMode001, TestSize.Level1)
501 {
502 auto pen = std::make_unique<Pen>();
503 ASSERT_TRUE(pen != nullptr);
504 pen->SetBlendMode(BlendMode::SRC_IN);
505 ASSERT_EQ(BlendMode::SRC_IN, pen->GetBlendMode());
506 }
507
508 /**
509 * @tc.name: GetterAndSetterOfBlendMode002
510 * @tc.desc:
511 * @tc.type: FUNC
512 * @tc.require: AR000GGNV3
513 * @tc.author:
514 */
515 HWTEST_F(PenTest, GetterAndSetterOfBlendMode002, TestSize.Level1)
516 {
517 auto pen = std::make_unique<Pen>();
518 ASSERT_TRUE(pen != nullptr);
519 pen->SetBlendMode(BlendMode::SRC_ATOP);
520 ASSERT_EQ(BlendMode::SRC_ATOP, pen->GetBlendMode());
521 }
522
523 /**
524 * @tc.name: GetterAndSetterOfAntiAlias001
525 * @tc.desc:
526 * @tc.type: FUNC
527 * @tc.require: AR000GGNV3
528 * @tc.author:
529 */
530 HWTEST_F(PenTest, GetterAndSetterOfAntiAlias001, TestSize.Level1)
531 {
532 auto pen = std::make_unique<Pen>();
533 ASSERT_TRUE(pen != nullptr);
534 pen->SetAntiAlias(true);
535 auto result = pen->IsAntiAlias();
536 EXPECT_TRUE(result == true);
537 }
538
539 /**
540 * @tc.name: GetterAndSetterOfAntiAlias002
541 * @tc.desc:
542 * @tc.type: FUNC
543 * @tc.require: AR000GGNV3
544 * @tc.author:
545 */
546 HWTEST_F(PenTest, GetterAndSetterOfAntiAlias002, TestSize.Level1)
547 {
548 auto pen = std::make_unique<Pen>();
549 ASSERT_TRUE(pen != nullptr);
550 pen->SetAntiAlias(false);
551 auto result = pen->IsAntiAlias();
552 EXPECT_TRUE(result == false);
553 }
554
555 /**
556 * @tc.name: GetterAndSetterOfPathEffect001
557 * @tc.desc:
558 * @tc.type: FUNC
559 * @tc.require: AR000GGNV3
560 * @tc.author:
561 */
562 HWTEST_F(PenTest, GetterAndSetterOfPathEffect001, TestSize.Level1)
563 {
564 auto pen = std::make_unique<Pen>();
565 ASSERT_TRUE(pen != nullptr);
566 auto pathEffect = std::make_shared<PathEffect>(PathEffect::PathEffectType::DASH, 0.2f);
567 ASSERT_TRUE(pathEffect != nullptr);
568 pen->SetPathEffect(pathEffect);
569 auto result = pen->GetPathEffect();
570 EXPECT_TRUE(result == pathEffect);
571 }
572
573 /**
574 * @tc.name: GetterAndSetterOfPathEffect002
575 * @tc.desc:
576 * @tc.type: FUNC
577 * @tc.require: AR000GGNV3
578 * @tc.author:
579 */
580 HWTEST_F(PenTest, GetterAndSetterOfPathEffect002, TestSize.Level1)
581 {
582 auto pen = std::make_unique<Pen>();
583 ASSERT_TRUE(pen != nullptr);
584 auto pathEffect = std::make_shared<PathEffect>(PathEffect::PathEffectType::COMPOSE, 0.1f);
585 ASSERT_TRUE(pathEffect != nullptr);
586 pen->SetPathEffect(pathEffect);
587 auto result = pen->GetPathEffect();
588 EXPECT_TRUE(result == pathEffect);
589 }
590
591 /**
592 * @tc.name: GetterAndSetterOfFilter001
593 * @tc.desc:
594 * @tc.type: FUNC
595 * @tc.require: AR000GGNV3
596 * @tc.author:
597 */
598 HWTEST_F(PenTest, GetterAndSetterOfFilter001, TestSize.Level1)
599 {
600 auto pen = std::make_unique<Pen>();
601 ASSERT_TRUE(pen != nullptr);
602 Filter filter;
603 pen->SetFilter(filter);
604 auto result = pen->GetFilter();
605 EXPECT_EQ(result, filter);
606 }
607
608 /**
609 * @tc.name: GetterAndSetterOfFilter002
610 * @tc.desc:
611 * @tc.type: FUNC
612 * @tc.require: AR000GGNV3
613 * @tc.author:
614 */
615 HWTEST_F(PenTest, GetterAndSetterOfFilter002, TestSize.Level1)
616 {
617 auto pen = std::make_unique<Pen>(255);
618 ASSERT_TRUE(pen != nullptr);
619 Filter filter;
620 pen->SetFilter(filter);
621 auto result = pen->GetFilter();
622 EXPECT_EQ(result, filter);
623 }
624
625 /**
626 * @tc.name: GetterAndSetterOfShaderEffect001
627 * @tc.desc:
628 * @tc.type: FUNC
629 * @tc.require: AR000GGNV3
630 * @tc.author:
631 */
632 HWTEST_F(PenTest, GetterAndSetterOfShaderEffect001, TestSize.Level1)
633 {
634 auto pen = std::make_unique<Pen>();
635 ASSERT_TRUE(pen != nullptr);
636 auto pathEffect = std::make_shared<PathEffect>(PathEffect::PathEffectType::NO_TYPE, 0.5f);
637 ASSERT_TRUE(pathEffect != nullptr);
638 pen->SetPathEffect(pathEffect);
639 auto result = pen->GetPathEffect();
640 EXPECT_EQ(result, pathEffect);
641 pen->Reset();
642 }
643
644 /**
645 * @tc.name: GetterAndSetterOfShaderEffect002
646 * @tc.desc:
647 * @tc.type: FUNC
648 * @tc.require: AR000GGNV3
649 * @tc.author:
650 */
651 HWTEST_F(PenTest, GetterAndSetterOfShaderEffect002, TestSize.Level1)
652 {
653 auto pen = std::make_unique<Pen>();
654 ASSERT_TRUE(pen != nullptr);
655 auto pathEffect = std::make_shared<PathEffect>(PathEffect::PathEffectType::CORNER, 0.2f);
656 ASSERT_TRUE(pathEffect != nullptr);
657 pen->SetPathEffect(pathEffect);
658 auto result = pen->GetPathEffect();
659 EXPECT_EQ(result, pathEffect);
660 pen->Reset();
661 }
662
663 /**
664 * @tc.name: OverrideEquals001
665 * @tc.desc:
666 * @tc.type: FUNC
667 * @tc.require: AR000GGNV3
668 * @tc.author:
669 */
670 HWTEST_F(PenTest, OverrideEquals001, TestSize.Level1)
671 {
672 Pen pen1;
673 Pen pen2 = Pen(255);
674 EXPECT_FALSE(pen1 == pen2);
675 }
676
677 /**
678 * @tc.name: OverrideEquals002
679 * @tc.desc:
680 * @tc.type: FUNC
681 * @tc.require: AR000GGNV3
682 * @tc.author:
683 */
684 HWTEST_F(PenTest, OverrideEquals002, TestSize.Level1)
685 {
686 Pen pen1;
687 Pen pen2 = pen1;
688 EXPECT_TRUE(pen1 == pen2);
689 }
690
691 /**
692 * @tc.name: OverrideNotEquals001
693 * @tc.desc:
694 * @tc.type: FUNC
695 * @tc.require: AR000GGNV3
696 * @tc.author:
697 */
698 HWTEST_F(PenTest, OverrideNotEquals001, TestSize.Level1)
699 {
700 Pen pen1;
701 Pen pen2 = Pen(255);
702 EXPECT_TRUE(pen1 != pen2);
703 }
704
705 /**
706 * @tc.name: OverrideNotEquals002
707 * @tc.desc:
708 * @tc.type: FUNC
709 * @tc.require: AR000GGNV3
710 * @tc.author:
711 */
712 HWTEST_F(PenTest, OverrideNotEquals002, TestSize.Level1)
713 {
714 Pen pen1 = Pen(128);
715 Pen pen2 = Pen(0);
716 EXPECT_TRUE(pen1 != pen1);
717 }
718 } // namespace Drawing
719 } // namespace Rosen
720 } // namespace OHOS
721