1 /*
2 * Copyright (c) 2024-2025 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, Hardware
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/path_iterator.h"
19 #include "draw/path.h"
20
21 using namespace testing;
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace Rosen {
26 namespace Drawing {
27 class PathIteratorTest : public testing::Test {
28 public:
29 static void SetUpTestCase();
30 static void TearDownTestCase();
31 void SetUp() override;
32 void TearDown() override;
33 };
34
SetUpTestCase()35 void PathIteratorTest::SetUpTestCase() {}
TearDownTestCase()36 void PathIteratorTest::TearDownTestCase() {}
SetUp()37 void PathIteratorTest::SetUp() {}
TearDown()38 void PathIteratorTest::TearDown() {}
39
40 /**
41 * @tc.name: CreatePathIterator001
42 * @tc.desc: test for creating pathIterator with path.
43 * @tc.type: FUNC
44 * @tc.require: IB0SY6
45 */
46 HWTEST_F(PathIteratorTest, CreatePathIterator001, TestSize.Level1)
47 {
48 auto path = std::make_unique<Path>();
49 std::unique_ptr<PathIterator> iter = std::make_unique<PathIterator>(*path);
50 ASSERT_TRUE(iter != nullptr);
51 }
52
53 /**
54 * @tc.name: NextTest001
55 * @tc.desc: test for next func.
56 * @tc.type: FUNC
57 * @tc.require: IB0SY6
58 */
59 HWTEST_F(PathIteratorTest, NextTest001, TestSize.Level1)
60 {
61 auto path = std::make_unique<Path>();
62 ASSERT_TRUE(path != nullptr);
63 // 4.5f, 5.0f for test
64 path->MoveTo(4.5f, 5.0f);
65 std::unique_ptr<PathIterator> iter = std::make_unique<PathIterator>(*path);
66 ASSERT_TRUE(iter != nullptr);
67 // 0, 0 for test
68 Point points[4] = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } };
69 // 0 for test
70 auto verb = iter->Next(points);
71 ASSERT_TRUE(verb == PathVerb::MOVE);
72 }
73
74 /**
75 * @tc.name: NextTest002
76 * @tc.desc: test for next func.
77 * @tc.type: FUNC
78 * @tc.require: ICDWVQ
79 */
80 HWTEST_F(PathIteratorTest, NextTest002, TestSize.Level1)
81 {
82 auto path = std::make_unique<Path>();
83 ASSERT_TRUE(path != nullptr);
84 std::unique_ptr<PathIterator> iter = std::make_unique<PathIterator>(*path);
85 ASSERT_TRUE(iter != nullptr);
86 // nullptr for test
87 auto verb = iter->Next(nullptr);
88 ASSERT_TRUE(verb == PathVerb::DONE);
89 }
90
91 /**
92 * @tc.name: PeekTest001
93 * @tc.desc: test for peek func.
94 * @tc.type: FUNC
95 * @tc.require: IB0SY6
96 */
97 HWTEST_F(PathIteratorTest, PeekTest001, TestSize.Level1)
98 {
99 auto path = std::make_unique<Path>();
100 ASSERT_TRUE(path != nullptr);
101 // 4.5f, 5.0f for test
102 path->MoveTo(4.5f, 5.0f);
103 std::unique_ptr<PathIterator> iter = std::make_unique<PathIterator>(*path);
104 ASSERT_TRUE(iter != nullptr);
105 auto verb = iter->Peek();
106 ASSERT_TRUE(verb == PathVerb::MOVE);
107 }
108
109 /**
110 * @tc.name: CreatePathIter001
111 * @tc.desc: test for creating PathIter with path.
112 * @tc.type: FUNC
113 * @tc.require: ICAWXU
114 */
115 HWTEST_F(PathIteratorTest, CreatePathIter001, TestSize.Level1)
116 {
117 auto path = std::make_unique<Path>();
118 std::unique_ptr<PathIter> iter = std::make_unique<PathIter>(*path, false);
119 ASSERT_TRUE(iter != nullptr);
120 }
121
122 /**
123 * @tc.name: PathIterNextTest001
124 * @tc.desc: test for PathIter next func.
125 * @tc.type: FUNC
126 * @tc.require: ICAWXU
127 */
128 HWTEST_F(PathIteratorTest, PathIterNextTest001, TestSize.Level1)
129 {
130 auto path = std::make_unique<Path>();
131 ASSERT_TRUE(path != nullptr);
132 path->MoveTo(4.5f, 5.0f); // 4.5f, 5.0f is the start point
133 path->LineTo(10.0f, 10.0f); // 10.0f, 10.0f is the end point
134 std::unique_ptr<PathIter> iter = std::make_unique<PathIter>(*path, false);
135 ASSERT_TRUE(iter != nullptr);
136 Point points[4] = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } };
137 auto verb = iter->Next(points);
138 ASSERT_TRUE(verb == PathVerb::MOVE);
139 ASSERT_EQ(points[0].GetX(), 4.5f); // 4.5f is the start point x
140 ASSERT_EQ(points[0].GetY(), 5.0f); // 5.0f is the start point y
141 auto verb2 = iter->Next(nullptr);
142 ASSERT_TRUE(verb2 == PathVerb::DONE);
143 }
144
145 /**
146 * @tc.name: PathIterConicWeightTest001
147 * @tc.desc: test PathIter ConicWeight with default and custom weights.
148 * @tc.type: FUNC
149 * @tc.require: ICAWXU
150 */
151 HWTEST_F(PathIteratorTest, PathIterConicWeightTest001, TestSize.Level1)
152 {
153 auto path = std::make_unique<Path>();
154 ASSERT_TRUE(path != nullptr);
155 path->MoveTo(0.0f, 0.0f);
156 // 50.0f, 50.0f is the control, 100.0f, 100.0f is the end, 2.0f is the weight
157 path->ConicTo(50.0f, 50.0f, 100.0f, 100.0f, 2.0f);
158 std::unique_ptr<PathIter> iter = std::make_unique<PathIter>(*path, false);
159 ASSERT_TRUE(iter != nullptr);
160 PathVerb verb;
161 bool isConic = false;
162 do {
163 Point points[4] = {}; // 4 is the max points
164 verb = iter->Next(points);
165 } while (verb != PathVerb::CONIC && verb != PathVerb::DONE);
166 if (verb == PathVerb::CONIC) {
167 isConic = true;
168 auto weight = iter->ConicWeight();
169 ASSERT_EQ(weight, 2.0f); // 2.0f is the weight
170 }
171 ASSERT_EQ(isConic, true);
172 }
173 } // namespace Drawing
174 } // namespace Rosen
175 } // namespace OHOS