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 <string>
17
18 #include "gtest/gtest.h"
19
20 #define private public
21 #define protected public
22
23 #include "include/core/SkStream.h"
24
25 #include "test/mock/core/rosen/mock_canvas.h"
26 #include "base/memory/ace_type.h"
27 #include "core/components/common/layout/constants.h"
28 #include "core/components/common/properties/color.h"
29 #include "core/components/declaration/svg/svg_animate_declaration.h"
30 #include "core/components/declaration/svg/svg_circle_declaration.h"
31 #include "core/components/declaration/svg/svg_declaration.h"
32 #include "core/components/declaration/svg/svg_ellipse_declaration.h"
33 #include "core/components/declaration/svg/svg_fe_colormatrix_declaration.h"
34 #include "core/components/declaration/svg/svg_fe_composite_declaration.h"
35 #include "core/components/declaration/svg/svg_fe_gaussianblur_declaration.h"
36 #include "core/components/declaration/svg/svg_filter_declaration.h"
37 #include "core/components/declaration/svg/svg_gradient_declaration.h"
38 #include "core/components/declaration/svg/svg_line_declaration.h"
39 #include "core/components/declaration/svg/svg_mask_declaration.h"
40 #include "core/components/declaration/svg/svg_path_declaration.h"
41 #include "core/components/declaration/svg/svg_pattern_declaration.h"
42 #include "core/components/declaration/svg/svg_polygon_declaration.h"
43 #include "core/components/declaration/svg/svg_rect_declaration.h"
44 #include "core/components/declaration/svg/svg_stop_declaration.h"
45 #include "core/components_ng/render/drawing.h"
46 #include "core/components_ng/svg/parse/svg_animation.h"
47 #include "core/components_ng/svg/parse/svg_circle.h"
48 #include "core/components_ng/svg/parse/svg_clip_path.h"
49 #include "core/components_ng/svg/parse/svg_defs.h"
50 #include "core/components_ng/svg/parse/svg_ellipse.h"
51 #include "core/components_ng/svg/parse/svg_fe_color_matrix.h"
52 #include "core/components_ng/svg/parse/svg_fe_composite.h"
53 #include "core/components_ng/svg/parse/svg_fe_gaussian_blur.h"
54 #include "core/components_ng/svg/parse/svg_filter.h"
55 #include "core/components_ng/svg/parse/svg_g.h"
56 #include "core/components_ng/svg/parse/svg_gradient.h"
57 #include "core/components_ng/svg/parse/svg_line.h"
58 #include "core/components_ng/svg/parse/svg_mask.h"
59 #include "core/components_ng/svg/parse/svg_path.h"
60 #include "core/components_ng/svg/parse/svg_pattern.h"
61 #include "core/components_ng/svg/parse/svg_polygon.h"
62 #include "core/components_ng/svg/parse/svg_rect.h"
63 #include "core/components_ng/svg/parse/svg_stop.h"
64 #include "core/components_ng/svg/parse/svg_style.h"
65 #include "core/components_ng/svg/parse/svg_svg.h"
66 #include "core/components_ng/svg/parse/svg_use.h"
67 #include "core/components_ng/svg/svg_dom.h"
68
69 using namespace testing;
70 using namespace testing::ext;
71 namespace OHOS::Ace::NG {
72 namespace {
73 const std::string CIRCLE_SVG_LABEL =
74 "<svg width=\"400px\" height=\"400px\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><circle cx=\"60px\" "
75 "cy=\"200px\" r = \"50px\" fill=\"red\" opacity=\"0.5\" stroke=\"blue\" stroke-width=\"16px\" "
76 "stroke-opacity=\"0.3\" id=\"circleId\"/></svg>";
77 constexpr float Cx = 60.0f;
78 constexpr float Cy = 200.0f;
79 constexpr float R = 50.0f;
80 const std::string CLIP_SVG_LABEL =
81 "<svg width=\"120\" height=\"120\" viewBox=\"0 0 120 120\" version=\"1.1\"><defs><clipPath id=\"myClip\"><circle "
82 "cx=\"30\" cy=\"30\" r=\"20\"/><circle cx=\"70\" cy=\"70\" r=\"30\"/></clipPath></defs><rect x=\"10\" y=\"10\" "
83 "width=\"100\" height=\"100\" clip-path=\"url(#myClip)\" fill=\"red\" /></svg>";
84 const std::string ID = "myClip";
85 const std::string SVG_LABEL = "<svg width=\"400\" height=\"500\" viewBox=\"-4 -10 300 300\"></svg>";
86 constexpr float WIDTH = 400.0f;
87 constexpr float HEIGHT = 500.0f;
88 constexpr float VIEWBOX_X = -4.0f;
89 constexpr float VIEWBOX_Y = -10.0f;
90 constexpr float VIEWBOX_WIDTH = 300.0f;
91 constexpr float VIEWBOX_HEIGHT = 300.0f;
92 const std::string USE_SVG_LABEL =
93 "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"24\" height=\"24\" "
94 "version=\"1.1\" viewBox=\"0 0 24 24\"><defs><path id=\"uxs-a\" d=\"M11.5,13.5 C12.7426407,13.5 13.75,14.5073593 "
95 "13.75,15.75 C13.75,16.9926407 12.7426407,18 11.5,18 C10.2573593,18 9.25,16.9926407 9.25,15.75 C9.25,14.5073593 "
96 "10.2573593,13.5 11.5,13.5 Z M11.5006868,9 C13.6153489,9 15.5906493,9.84916677 16.9758057,11.3106505 "
97 "C17.3557222,11.7115019 17.3387512,12.3444394 16.9378998,12.724356 C16.5370484,13.1042725 15.9041109,13.0873015 "
98 "15.5241943,12.6864501 C14.5167672,11.62351 13.0663814,11 11.5006868,11 C9.93437756,11 8.48347933,11.6240033 "
99 "7.47603048,12.6876625 C7.09624495,13.0886381 6.46331303,13.105816 6.06233747,12.7260305 C5.66136192,12.3462449 "
100 "5.644184,11.713313 6.02396952,11.3123375 C7.40917586,9.84984392 9.38518621,9 11.5006868,9 Z M11.5002692,4.5 "
101 "C14.7685386,4.5 17.818619,5.90678629 19.9943022,8.33155689 C20.3631417,8.74262367 20.3289097,9.37486259 "
102 "19.9178429,9.74370206 C19.5067762,10.1125415 18.8745372,10.0783095 18.5056978,9.66724276 C16.703513,7.6587313 "
103 "14.1912454,6.5 11.5002692,6.5 C8.80904291,6.5 6.29656204,7.6589485 4.49435171,9.66778779 C4.1255427,10.0788819 "
104 "3.49330631,10.1131607 3.08221221,9.74435171 C2.67111811,9.3755427 2.63683928,8.74330631 3.00564829,8.33221221 "
105 "C5.1813597,5.90704879 8.23169642,4.5 11.5002692,4.5 Z M11.4995363,-5.68434189e-14 C15.8001105,-5.68434189e-14 "
106 "19.8214916,1.76017363 22.7244081,4.81062864 C23.1051374,5.21070819 23.0894509,5.84367883 22.6893714,6.22440812 "
107 "C22.2892918,6.60513741 21.6563212,6.58945092 21.2755919,6.18937136 C18.7465254,3.53176711 15.2469734,2 "
108 "11.4995363,2 C7.75253773,2 4.25335915,3.53140612 1.72434435,6.1884639 C1.34357805,6.58850824 "
109 "0.71060597,6.60413618 0.310561632,6.22336988 C-0.0894827058,5.84260359 -0.105110646,5.2096315 "
110 "0.27565565,4.80958716 C3.1785132,1.75975912 7.19946582,-5.68434189e-14 11.4995363,-5.68434189e-14 "
111 "Z\"/></defs><use fill=\"red\" fill-rule=\"nonzero\" stroke=\"blue\" stroke-width=\"1\" "
112 "transform=\"translate(.5 2.75)\" xlink:href=\"#uxs-a\"/></svg>";
113 const std::string HREF = "uxs-a";
114 const std::string FILL_RULE = "nonzero";
115 const std::string TRANSFORM = "translate(.5 2.75)";
116 constexpr float STROKE_WIDTH = 1;
117 constexpr int32_t INDEX_ONE = 1;
118 constexpr int32_t STROKE = 0xff0000ff;
119 const std::string STYLE_SVG_LABEL = "<svg viewBox=\"0 0 10 10\"><style>circle{fill:gold;stroke:maroon;stroke-width : "
120 "2px;}</style><circle cx =\"5\" cy=\"5\" r=\"4\" /></svg>";
121 const std::string STOP_SVG_LABEL =
122 "<svg height=\"150\" width=\"400\"><defs><linearGradient id=\"grad1\" x1=\"0%\" y1=\"0%\" x2=\"100%\" "
123 "y2=\"0%\"><stop offset=\"0%\" style=\"stop-color:rgb(255,255,0);stop-opacity:1\" /><stop offset=\"20px\" "
124 "style=\"stop-color:rgb(255,0,0);stop-opacity:1\" /></linearGradient></defs><ellipse cx=\"200\" cy=\"70\" "
125 "rx=\"85\" ry=\"55\" fill=\"url(#grad1)\" /></svg>";
126 constexpr int32_t INDEX_ZEARO = 0;
127 constexpr int32_t CHILD_NUMBER = 2;
128 constexpr float STOP_OPACITY = 1.0f;
129 const std::string RECT_SVG_LABEL = "<svg width=\"400\" height=\"400\" version=\"1.1\" fill=\"red\" "
130 "xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"100\" height=\"100\" x=\"150\" "
131 "y=\"20\" stroke-width=\"4\" stroke=\"#000000\" rx=\"10\" ry=\"10\"></rect></svg>";
132 const std::string RECT_SVG_LABEL2 = "<svg version=\"1.1\" fill=\"red\" "
133 "xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"100\" height=\"100\" x=\"150\" "
134 "y=\"20\" stroke-width=\"4\" stroke=\"#000000\" rx=\"10\" ry=\"10\"></rect></svg>";
135 const std::string RECT_SVG_LABEL3 = "<svg version=\"1.1\" fill=\"red\" "
136 "xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"100\" height=\"100\" x=\"150\" "
137 "y=\"20\" stroke-width=\"4\" stroke=\"#000000\" rx=\"1\" ry=\"-1\"></rect></svg>";
138 constexpr float X = 150.0f;
139 constexpr float Y = 20.0f;
140 constexpr float RX = 10.0f;
141 constexpr float RY = 10.0f;
142 constexpr float RECT_WIDTH = 100.0f;
143 constexpr float RECT_HEIGHT = 100.0f;
144 const std::string POLYGON_SVG_LABEL1 =
145 "<svg fill=\"white\" stroke=\"blue\" width=\"800\" height=\"400\" version=\"1.1\" "
146 "xmlns=\"http://www.w3.org/2000/svg\"><polygon points=\"10,110 60,35 60,85 110,10\" "
147 "fill=\"red\"></polygon> <polyline points=\"10,200 60,125 60,175 110,100\" "
148 "stroke-dasharray=\"10 5\" stroke-dashoffset=\"3\"></polyline></svg>";
149 const std::string POLYGON_SVG_LABEL2 =
150 "<svg fill=\"white\" stroke=\"blue\" width=\"300\" height=\"400\" version=\"1.1\" "
151 "xmlns=\"http://www.w3.org/2000/svg\"><polygon points=\"10,110 60,35 60,85 110,10\" "
152 "fill=\"red\"></polygon> <polyline points=\"10,200 60,125 60,175 110,100\" "
153 "stroke-dasharray=\"10 5\" stroke-dashoffset=\"3\"></polyline></svg>";
154 const std::string POLYGON_POINT = "10,110 60,35 60,85 110,10";
155 const std::string POLYLINE_POINT = "10,200 60,125 60,175 110,100";
156 const std::string PATTERN_SVG_LABEL =
157 "<svg viewBox=\"0 0 230 100\"><defs><pattern id=\"star\" viewBox=\"0 0 10 10\" width=\"10\" "
158 "height=\"10\"><polygon points=\"0,0 2,5 0,10 5,8 10,10 8,5 10,0 5,2\" /></pattern></defs><circle cx=\"50\" "
159 "cy=\"50\" r=\"50\" fill=\"url(#star)\" /><circle cx=\"180\" cy=\"50\" r=\"40\" fill=\"none\" stroke-width=\"20\" "
160 "stroke=\"url(#star)\"/> </svg>";
161 constexpr float PATTERN_WIDTH = 10.0f;
162 constexpr float PATTERN_HEIGHT = 10.0f;
163 constexpr float PATTERN_VIEWBOX_X = 0.0f;
164 constexpr float PATTERN_VIEWBOX_Y = 0.0f;
165 constexpr float PATTERN_VIEWBOX_WIDTH = 10.0f;
166 constexpr float PATTERN_VIEWBOX_HEIGHT = 10.0f;
167 const std::string PATH_SVG_LABEL1 =
168 "<svg width=\"400\" height=\"800\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M 10,30 A 20,20 "
169 "0,0,1 50,30 A 20,20 0,0,1 90,30 Q 90,60 50,90 Q 10,60 10,30 z\" stroke=\"blue\" stroke-width=\"3\" "
170 "fill=\"red\"></path></svg>";
171 const std::string PATH_SVG_LABEL2 =
172 "<svg version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M 10,30 A 20,20 "
173 "0,0,1 50,30 A 20,20 0,0,1 90,30 Q 90,60 50,90 Q 10,60 10,30 z\" stroke=\"blue\" stroke-width=\"3\" "
174 "fill=\"red\"></path></svg>";
175 const std::string PATH_SVG_LABEL3 =
176 "<svg width=\"-400\" height=\"-400\" viewBox=\"-4 -10 300 300\" version=\"1.1\" "
177 "xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M 10,30 A 20,20 "
178 "0,0,1 50,30 A 20,20 0,0,1 90,30 Q 90,60 50,90 Q 10,60 10,30 z\" stroke=\"blue\" stroke-width=\"3\" "
179 "fill=\"red\"></path></svg>";
180 const std::string PATH_SVG_LABEL4 =
181 "<svg width=\"300\" height=\"400\" viewBox=\"-4 -10 300 300\" version=\"1.1\" "
182 "xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M 10,30 A 20,20 "
183 "0,0,1 50,30 A 20,20 0,0,1 90,30 Q 90,60 50,90 Q 10,60 10,30 z\" stroke=\"blue\" stroke-width=\"3\" "
184 "fill=\"red\"></path></svg>";
185 const std::string PATH_SVG_LABEL5 =
186 "<svg width=\"400\" height=\"400\" viewBox=\"-4 -10 -300 -300\" version=\"1.1\" "
187 "xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M 10,30 A 20,20 "
188 "0,0,1 50,30 A 20,20 0,0,1 90,30 Q 90,60 50,90 Q 10,60 10,30 z\" stroke=\"blue\" stroke-width=\"3\" "
189 "fill=\"red\"></path></svg>";
190 const std::string PATH_CMD = "M 10,30 A 20,20 0,0,1 50,30 A 20,20 0,0,1 90,30 Q 90,60 50,90 Q 10,60 10,30 z";
191 const std::string MASK_SVG_LABEL =
192 "<svg width=\"50px\" height=\"50px\" viewBox=\"0 0 24 24\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" "
193 "xmlns:xlink=\"http://www.w3.org/1999/xlink\"><defs><path d=\"M4.3,14l-2,1.8c-0.2,0.2 -0.5,0.2 -0.7,0c-0.1,-0.1 "
194 "-0.1,-0.2 -0.1,-0.3V8.6c0,-0.3 0.2,-0.5 0.5,-0.5c0.1,0 0.2,0 0.3,0.1l2,1.8l0,0H10L7,3.5C6.7,2.9 6.9,2.3 "
195 "7.5,2c0.6,-0.3 1.3,-0.1 1.7,0.4l6,7.6l0,0H21c1.1,0 2,0.9 2,2s-0.9,2 -2,2h-6l0,0l-5.8,7.6c-0.4,0.5 -1.1,0.7 "
196 "-1.7,0.4c-0.6,-0.3 -0.8,-0.9 -0.5,-1.5l3,-6.5l0,0H4.3z\" id=\"path-1\"></path></defs><g stroke=\"none\" "
197 "stroke-width=\"1\" fill=\"none\" fill-rule=\"evenodd\"><g><mask id=\"mask-2\" fill=\"#FFFFFF\"><use "
198 "xlink:href=\"#path-1\"></use></mask><use id=\"myId\" fill=\"#FFFFFF\" fill-rule=\"nonzero\" "
199 "xlink:href=\"#path-1\"></use></g></g></svg>";
200 const std::string MASK_ID = "mask-2";
201 const std::string LINE_SVG_LABEL =
202 "<svg width=\"400\" height=\"400\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><line x1=\"10\" x2=\"300\" "
203 "y1=\"50\" y2=\"50\" stroke-width=\"4\" fill=\"white\" stroke=\"blue\"></line></svg>";
204 constexpr float X1 = 10.0f;
205 constexpr float Y1 = 50.0f;
206 constexpr float X2 = 300.0f;
207 constexpr float Y2 = 50.0f;
208 const std::string GRADIENT_SVG_LINEAR =
209 "<svg height=\"150\" width=\"400\"><defs><linearGradient id=\"grad1\" x1=\"0%\" y1=\"0%\" x2=\"100%\" "
210 "y2=\"0%\"><stop offset=\"0%\" style=\"stop-color:rgb(255,255,0);stop-opacity:1\" /><stop offset=\"100%\" "
211 "style=\"stop-color:rgb(255,0,0);stop-opacity:1\" /></linearGradient></defs><ellipse cx=\"200\" cy=\"70\" "
212 "rx=\"85\" ry=\"55\" fill=\"url(#grad1)\" /></svg>";
213 const std::string GRADIENT_SVG_RADIAL =
214 "<svg height=\"150\" width=\"500\"><defs><radialGradient id=\"grad1\" cx=\"50%\" cy=\"50%\" r=\"50%\" fx=\"50%\" "
215 "fy=\"50%\"><stop offset=\"0%\" style=\"stop-color:rgb(255,255,255); stop-opacity:0\" /><stop offset=\"100%\" "
216 "style=\"stop-color:rgb(0,0,255);stop-opacity:1\" /></radialGradient></defs><ellipse cx=\"200\" cy=\"70\" "
217 "rx=\"85\" ry=\"55\" fill=\"url(#grad1)\" /></svg>";
218 constexpr float ZERO = 0.0f;
219 const std::string G_SVG_LABEL = "<svg width=\"400\" height=\"500\"> <g id=\"myId\"> </g></svg>";
220 const std::string G_ID = "myId";
221 const std::string FILTER_SVG_LABEL =
222 "<svg height=\"900\" width=\"900\"><filter id=\"composite\" y=\"0\" x=\"0\" width=\"900\" "
223 "height=\"900\"><feTurbulence baseFrequency=\".05\" numOctaves=\"3\" result=\"B\"/><feComposite in2=\"B\" "
224 "in=\"SourceGraphic\" operator=\"in\" /></filter><ellipse cx=\"100\" cy=\"87\" rx=\"75\" ry=\"87\" fill=\"red\" "
225 "filter=\"url(#composite)\"/></svg>";
226 const std::string FILTER_ID = "composite";
227 constexpr float FILTER_WIDTH = 900.0f;
228 constexpr float FILTER_HEIGHT = 900.0f;
229 const std::string FEGAUSS_SVG_LABEL =
230 "<svg width=\"230\" height=\"120\"><filter id=\"blurMe\"><feGaussianBlur in=\"Graphic\" stdDeviation=\"5\" "
231 "/></filter><circle cx=\"170\" cy=\"60\" r=\"50\" fill=\"green\" filter=\"url(#blurMe)\" /></svg>";
232 const std::string FEGAUSS_SVG_LABEL2 =
233 "<svg width=\"-230\" height=\"-120\"><filter id=\"blurMe\"><feGaussianBlur in=\"Graphic\" stdDeviation=\"5\" "
234 "/></filter><circle cx=\"170\" cy=\"60\" r=\"50\" fill=\"green\" filter=\"url(#blurMe)\" /></svg>";
235 constexpr float STD_DEVIATION = 5.0f;
236 const std::string COMPOSITE_SVG_LABEL =
237 "<svg height=\"900\" width=\"900\"><filter id=\"composite\" y=\"0\" x=\"0\" width=\"100%\" "
238 "height=\"100%\"><feComposite in2=\"B\" "
239 "in=\"SourceGraphic\" operator=\"in\" /></filter><ellipse cx=\"100\" cy=\"87\" rx=\"75\" ry=\"87\" fill=\"red\" "
240 "filter=\"url(#composite)\"/></svg>";
241 const std::string COLOR_MATRIX_SVG_LABEL =
242 "<svg height=\"900\" width=\"900\"><filter id=\"linear\"><feColorMatrix type=\"matrix\" "
243 "values=\"R 0 0 0 0 0 G 0 0 0 0 0 B 0 0 0 0 0 A 0\"></feColorMatrix ></filter><ellipse cx=\"100\" cy=\"87\" "
244 "rx=\"75\" ry=\"87\" fill=\"red\" filter=\"url(#linear)\"></ellipse></svg>";
245 const std::string TYPE = "matrix";
246 const std::string VALUE = "R 0 0 0 0 0 G 0 0 0 0 0 B 0 0 0 0 0 A 0";
247 const std::string ELLIPSE_SVG_LABEL1 =
248 "<svg fill=\"white\" width=\"400\" height=\"400\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><ellipse "
249 "cx=\"60\" cy=\"200\" rx=\"50\" ry=\"100\" stroke-width=\"4\" fill=\"red\" stroke=\"blue\"></ellipse></svg>";
250 const std::string ELLIPSE_SVG_LABEL2 =
251 "<svg fill=\"white\" width=\"10\" height=\"10\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><ellipse "
252 "cx=\"60\" cy=\"200\" rx=\"50\" ry=\"100\" stroke-width=\"4\" fill=\"red\" stroke=\"blue\"></ellipse></svg>";
253 const std::string ELLIPSE_SVG_LABEL3 =
254 "<svg fill=\"white\" width=\"10\" height=\"10\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><ellipse "
255 "cx=\"0.0\" cy=\"0.0\" rx=\"-1\" ry=\"-1\" stroke-width=\"4\" fill=\"red\" stroke=\"blue\"></ellipse></svg>";
256 const std::string ELLIPSE_SVG_LABEL4 =
257 "<svg fill=\"white\" width=\"10\" height=\"10\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><ellipse "
258 "cx=\"0.0\" cy=\"0.0\" rx=\"1\" ry=\"-1\" stroke-width=\"4\" fill=\"red\" stroke=\"blue\"></ellipse></svg>";
259 constexpr float ELLIPSE_Cx = 60.0f;
260 constexpr float ELLIPSE_Cy = 200.0f;
261 constexpr float ELLIPSE_RX = 50.0f;
262 constexpr float ELLIPSE_RY = 100.0f;
263 const std::string SVG_ANIMATE_TRANSFORM(
264 "<svg width=\"200px\" height=\"200px\" viewBox=\"0 0 100 100\" xmlns=\"http://www.w3.org/2000/svg\">"
265 "<path d =\"M50 50L20 50A30 30 0 0 0 80 50Z\">"
266 "<animateTransform attributeName =\"transform\" type=\"rotate\" repeatCount=\"3\" dur=\"1s\""
267 " values=\"0 50 50;45 50 50;0 50 50\" keyTimes=\"0;0.5;1\"></animateTransform></path></svg>");
268
269 constexpr float IMAGE_COMPONENT_WIDTH = 100.0f;
270 constexpr float IMAGE_COMPONENT_HEIGHT = 100.0f;
271 } // namespace
272 class ParseTestNg : public testing::Test {
273 public:
274 static RefPtr<SvgDom> ParseRect(const std::string& svgLabel);
275 RefPtr<SvgDom> parsePolygon(const std::string& svgLable);
276 static RefPtr<SvgDom> ParsePath(const std::string& svgLabel);
277 RefPtr<SvgDom> ParseFeGaussianblur(const std::string& svgLabel);
278 static RefPtr<SvgDom> ParseEllipse(const std::string& svgLabel);
279 void CallBack(Testing::MockCanvas& rSCanvas);
280 };
281
ParseRect(const std::string & svgLabel)282 RefPtr<SvgDom> ParseTestNg::ParseRect(const std::string& svgLabel)
283 {
284 auto svgStream = SkMemoryStream::MakeCopy(RECT_SVG_LABEL.c_str(), RECT_SVG_LABEL.length());
285 EXPECT_NE(svgStream, nullptr);
286 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
287 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
288 EXPECT_NE(svg, nullptr);
289 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
290 auto svgRect = AceType::DynamicCast<SvgRect>(svg->children_.at(0));
291 EXPECT_NE(svgRect, nullptr);
292 auto rectDeclaration = AceType::DynamicCast<SvgRectDeclaration>(svgRect->declaration_);
293 EXPECT_NE(rectDeclaration, nullptr);
294 EXPECT_FLOAT_EQ(rectDeclaration->GetX().ConvertToPx(), X);
295 EXPECT_FLOAT_EQ(rectDeclaration->GetY().ConvertToPx(), Y);
296 EXPECT_FLOAT_EQ(rectDeclaration->GetRx().ConvertToPx(), RX);
297 EXPECT_FLOAT_EQ(rectDeclaration->GetRy().ConvertToPx(), RY);
298 EXPECT_FLOAT_EQ(rectDeclaration->GetWidth().ConvertToPx(), RECT_WIDTH);
299 EXPECT_FLOAT_EQ(rectDeclaration->GetHeight().ConvertToPx(), RECT_HEIGHT);
300 return svgDom;
301 }
302
parsePolygon(const std::string & svgLable)303 RefPtr<SvgDom> ParseTestNg::parsePolygon(const std::string& svgLable)
304 {
305 auto svgStream = SkMemoryStream::MakeCopy(svgLable.c_str(), svgLable.length());
306 EXPECT_NE(svgStream, nullptr);
307 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
308 EXPECT_NE(svgDom, nullptr);
309 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
310 EXPECT_NE(svg, nullptr);
311 EXPECT_EQ(static_cast<int32_t>(svg->children_.size()), CHILD_NUMBER);
312 auto svgPolygon = AceType::DynamicCast<SvgPolygon>(svg->children_.at(0));
313 EXPECT_NE(svgPolygon, nullptr);
314 auto svgPolyline = AceType::DynamicCast<SvgPolygon>(svg->children_.at(1));
315 EXPECT_NE(svgPolyline, nullptr);
316 auto polygonDeclaration = AceType::DynamicCast<SvgPolygonDeclaration>(svgPolygon->declaration_);
317 EXPECT_NE(polygonDeclaration, nullptr);
318 EXPECT_STREQ(polygonDeclaration->GetPoints().c_str(), POLYGON_POINT.c_str());
319 auto polylineDeclaration = AceType::DynamicCast<SvgPolygonDeclaration>(svgPolyline->declaration_);
320 EXPECT_NE(polylineDeclaration, nullptr);
321 EXPECT_STREQ(polylineDeclaration->GetPoints().c_str(), POLYLINE_POINT.c_str());
322 return svgDom;
323 }
324
ParsePath(const std::string & svgLabel)325 RefPtr<SvgDom> ParseTestNg::ParsePath(const std::string& svgLabel)
326 {
327 auto svgStream = SkMemoryStream::MakeCopy(svgLabel.c_str(), svgLabel.length());
328 EXPECT_NE(svgStream, nullptr);
329 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
330 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
331 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
332 auto svgPath = AceType::DynamicCast<SvgPath>(svg->children_.at(0));
333 EXPECT_NE(svgPath, nullptr);
334 auto pathDeclaration = AceType::DynamicCast<SvgPathDeclaration>(svgPath->declaration_);
335 EXPECT_STREQ(pathDeclaration->GetD().c_str(), PATH_CMD.c_str());
336 return svgDom;
337 }
338
ParseFeGaussianblur(const std::string & svgLabel)339 RefPtr<SvgDom> ParseTestNg::ParseFeGaussianblur(const std::string& svgLabel)
340 {
341 auto svgStream = SkMemoryStream::MakeCopy(svgLabel.c_str(), svgLabel.length());
342 EXPECT_NE(svgStream, nullptr);
343 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
344 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
345 EXPECT_GT(svg->children_.size(), 0);
346 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
347 EXPECT_NE(svgFilter, nullptr);
348 auto svgFeGaussiaBlur = AceType::DynamicCast<SvgFeGaussianBlur>(svgFilter->children_.at(0));
349 EXPECT_NE(svgFeGaussiaBlur, nullptr);
350 auto feDeclaration = AceType::DynamicCast<SvgFeGaussianBlurDeclaration>(svgFeGaussiaBlur->declaration_);
351 EXPECT_NE(feDeclaration, nullptr);
352 EXPECT_FLOAT_EQ(feDeclaration->GetStdDeviation(), STD_DEVIATION);
353 EXPECT_EQ(feDeclaration->GetEdgeMode(), FeEdgeMode::EDGE_DUPLICATE);
354 return svgDom;
355 }
356
ParseEllipse(const std::string & svgLabel)357 RefPtr<SvgDom> ParseTestNg::ParseEllipse(const std::string& svgLabel)
358 {
359 auto svgStream = SkMemoryStream::MakeCopy(svgLabel.c_str(), svgLabel.length());
360 EXPECT_NE(svgStream, nullptr);
361 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
362 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
363 EXPECT_GT(svg->children_.size(), 0);
364 auto svgEllipse = AceType::DynamicCast<SvgEllipse>(svg->children_.at(0));
365 EXPECT_NE(svgEllipse, nullptr);
366 auto ellipseDeclaration = AceType::DynamicCast<SvgEllipseDeclaration>(svgEllipse->declaration_);
367 EXPECT_FLOAT_EQ(ellipseDeclaration->GetCx().ConvertToPx(), ELLIPSE_Cx);
368 EXPECT_FLOAT_EQ(ellipseDeclaration->GetCy().ConvertToPx(), ELLIPSE_Cy);
369 EXPECT_FLOAT_EQ(ellipseDeclaration->GetRx().ConvertToPx(), ELLIPSE_RX);
370 EXPECT_FLOAT_EQ(ellipseDeclaration->GetRy().ConvertToPx(), ELLIPSE_RY);
371 return svgDom;
372 }
373
CallBack(Testing::MockCanvas & rSCanvas)374 void ParseTestNg::CallBack(Testing::MockCanvas& rSCanvas)
375 {
376 EXPECT_CALL(rSCanvas, AttachBrush(_)).WillRepeatedly(ReturnRef(rSCanvas));
377 EXPECT_CALL(rSCanvas, DetachBrush()).WillRepeatedly(ReturnRef(rSCanvas));
378 EXPECT_CALL(rSCanvas, AttachPen(_)).WillRepeatedly(ReturnRef(rSCanvas));
379 EXPECT_CALL(rSCanvas, DetachPen()).WillRepeatedly(ReturnRef(rSCanvas));
380 EXPECT_CALL(rSCanvas, DrawPath(_)).Times(AtLeast(1));
381 }
382
383 /**
384 * @tc.name: ParseTest001
385 * @tc.desc: parse circle label
386 * @tc.type: FUNC
387 */
388 HWTEST_F(ParseTestNg, ParseCircleTest001, TestSize.Level1)
389 {
390 auto svgStream = SkMemoryStream::MakeCopy(CIRCLE_SVG_LABEL.c_str(), CIRCLE_SVG_LABEL.length());
391 EXPECT_NE(svgStream, nullptr);
392 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
393 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
394 EXPECT_GT(svg->children_.size(), 0);
395 auto svgLine = AceType::DynamicCast<SvgCircle>(svg->children_.at(0));
396 EXPECT_NE(svgLine, nullptr);
397 auto circleDeclaration = AceType::DynamicCast<SvgCircleDeclaration>(svgLine->declaration_);
398 EXPECT_FLOAT_EQ(circleDeclaration->GetCx().ConvertToPx(), Cx);
399 EXPECT_FLOAT_EQ(circleDeclaration->GetCy().ConvertToPx(), Cy);
400 EXPECT_FLOAT_EQ(circleDeclaration->GetR().ConvertToPx(), R);
401 Testing::MockCanvas rSCanvas;
402 CallBack(rSCanvas);
403 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
404 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
405 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
406 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
407 }
408
409 /**
410 * @tc.name: ParseAnimation
411 * @tc.desc: parse animation path label
412 * @tc.type: FUNC
413 */
414 HWTEST_F(ParseTestNg, ParseAnimation, TestSize.Level1)
415 {
416 SvgAnimation* svgAnimation = new SvgAnimation(SvgAnimateType::ANIMATE);
417 EXPECT_NE(svgAnimation, nullptr);
418 auto svgAnimate = svgAnimation->Create();
419 EXPECT_NE(svgAnimate, nullptr);
420 auto svgMotion = svgAnimation->CreateAnimateMotion();
421 EXPECT_NE(svgMotion, nullptr);
422 auto svgTransform = svgAnimation->CreateAnimateTransform();
423 EXPECT_NE(svgTransform, nullptr);
424 svgAnimation->SetAttr(ID, CLIP_SVG_LABEL);
425 svgAnimation->UpdateAttr();
426 EXPECT_EQ(svgAnimation->ConvertCalcMode(ID), CalcMode::LINEAR);
427 delete svgAnimation;
428 }
429
430 /**
431 * @tc.name: ParseClipPathTest001
432 * @tc.desc: parse clip path label
433 * @tc.type: FUNC
434 */
435 HWTEST_F(ParseTestNg, ParseClipPathTest001, TestSize.Level1)
436 {
437 auto svgStream = SkMemoryStream::MakeCopy(CLIP_SVG_LABEL.c_str(), CLIP_SVG_LABEL.length());
438 EXPECT_NE(svgStream, nullptr);
439 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
440 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
441 EXPECT_GT(svg->children_.size(), 0);
442 auto svgDefs = AceType::DynamicCast<SvgDefs>(svg->children_.at(0));
443 EXPECT_NE(svgDefs, nullptr);
444 auto svgClipPath = AceType::DynamicCast<SvgClipPath>(svgDefs->children_.at(0));
445 EXPECT_NE(svgClipPath, nullptr);
446 EXPECT_STREQ(svgClipPath->nodeId_.c_str(), ID.c_str());
447 Testing::MockCanvas rSCanvas;
448 CallBack(rSCanvas);
449 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
450 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
451 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
452 EXPECT_EQ(svgDom->viewBox_.IsValid(), true);
453 }
454
455 /**
456 * @tc.name: ParseSvgTest001
457 * @tc.desc: parse svg label
458 * @tc.type: FUNC
459 */
460 HWTEST_F(ParseTestNg, ParseSvgTest001, TestSize.Level1)
461 {
462 auto svgStream = SkMemoryStream::MakeCopy(SVG_LABEL.c_str(), SVG_LABEL.length());
463 EXPECT_NE(svgStream, nullptr);
464 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
465 EXPECT_FLOAT_EQ(svgDom->svgSize_.Width(), WIDTH);
466 EXPECT_FLOAT_EQ(svgDom->svgSize_.Height(), HEIGHT);
467 EXPECT_FLOAT_EQ(svgDom->viewBox_.Left(), VIEWBOX_X);
468 EXPECT_FLOAT_EQ(svgDom->viewBox_.Top(), VIEWBOX_Y);
469 EXPECT_FLOAT_EQ(svgDom->viewBox_.Width(), VIEWBOX_WIDTH);
470 EXPECT_FLOAT_EQ(svgDom->viewBox_.Height(), VIEWBOX_HEIGHT);
471 }
472
473 /**
474 * @tc.name: ParseUseTest001
475 * @tc.desc: parse use label
476 * @tc.type: FUNC
477 */
478 HWTEST_F(ParseTestNg, ParseUseTest001, TestSize.Level1)
479 {
480 auto svgStream = SkMemoryStream::MakeCopy(USE_SVG_LABEL.c_str(), USE_SVG_LABEL.length());
481 EXPECT_NE(svgStream, nullptr);
482 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::GREEN);
483 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
484 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
485 auto svgUse = AceType::DynamicCast<SvgUse>(svg->children_.at(INDEX_ONE));
486 EXPECT_NE(svgUse, nullptr);
487 auto svgUseDeclaration = AceType::DynamicCast<SvgDeclaration>(svgUse->declaration_);
488 EXPECT_NE(svgUseDeclaration, nullptr);
489 auto fillState = svgUseDeclaration->GetFillState();
490 EXPECT_STREQ(fillState.GetFillRule().c_str(), FILL_RULE.c_str());
491 EXPECT_STREQ(svgUseDeclaration->GetTransform().c_str(), TRANSFORM.c_str());
492 auto stroke = svgUseDeclaration->GetStrokeState();
493 EXPECT_FLOAT_EQ(STROKE_WIDTH, stroke.GetLineWidth().ConvertToPx());
494 EXPECT_EQ(stroke.HasStroke(), true);
495 EXPECT_STREQ(stroke.GetColor().ColorToString().c_str(), Color(STROKE).ColorToString().c_str());
496 EXPECT_STREQ(svgUseDeclaration->GetHref().c_str(), HREF.c_str());
497 Testing::MockCanvas rSCanvas;
498 CallBack(rSCanvas);
499 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
500 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
501 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
502 EXPECT_EQ(svgDom->viewBox_.IsValid(), true);
503
504 // <Use> shouldn't overwrite attributes of the referenced <Path>
505 auto svgPath = svgDom->svgContext_->GetSvgNodeById(HREF);
506 auto pathDeclaration = svgPath->declaration_;
507 EXPECT_NE(pathDeclaration->GetFillState().GetFillRule().c_str(), FILL_RULE.c_str());
508 EXPECT_NE(pathDeclaration->GetFillState().GetColor(), Color::RED);
509 EXPECT_NE(pathDeclaration->GetTransform().c_str(), TRANSFORM.c_str());
510 EXPECT_NE(pathDeclaration->GetStrokeState().GetColor(), Color(STROKE));
511 }
512
513 /**
514 * @tc.name: ParseStyleTest001
515 * @tc.desc: parse style label
516 * @tc.type: FUNC
517 */
518
519 HWTEST_F(ParseTestNg, ParseStyleTest001, TestSize.Level1)
520 {
521 auto svgStream = SkMemoryStream::MakeCopy(STYLE_SVG_LABEL.c_str(), STYLE_SVG_LABEL.length());
522 EXPECT_NE(svgStream, nullptr);
523 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
524 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
525 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
526 auto svgStyle = AceType::DynamicCast<SvgStyle>(svg->children_.at(0));
527 EXPECT_NE(svgStyle, nullptr);
528 // todo parse style attr
529 Testing::MockCanvas rSCanvas;
530 CallBack(rSCanvas);
531 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
532 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
533 EXPECT_EQ(svgDom->svgSize_.IsValid(), false);
534 EXPECT_EQ(svgDom->viewBox_.IsValid(), true);
535 }
536
537 /**
538 * @tc.name: ParseStopTest001
539 * @tc.desc: parse stop label
540 * @tc.type: FUNC
541 */
542
543 HWTEST_F(ParseTestNg, ParseStopTest001, TestSize.Level1)
544 {
545 auto svgStream = SkMemoryStream::MakeCopy(STOP_SVG_LABEL.c_str(), STOP_SVG_LABEL.length());
546 EXPECT_NE(svgStream, nullptr);
547 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
548 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
549 EXPECT_EQ(static_cast<int32_t>(svg->children_.size()), CHILD_NUMBER);
550 auto defers = AceType::DynamicCast<SvgDefs>(svg->children_.at(INDEX_ZEARO));
551 EXPECT_NE(defers, nullptr);
552 auto svgGradient = AceType::DynamicCast<SvgGradient>(defers->children_.at(INDEX_ZEARO));
553 EXPECT_NE(svgGradient, nullptr);
554 auto svgStop = AceType::DynamicCast<SvgStop>(svgGradient->children_.at(INDEX_ZEARO));
555 EXPECT_NE(svgStop, nullptr);
556 auto svgStopDeclaration = AceType::DynamicCast<SvgStopDeclaration>(svgStop->declaration_);
557 EXPECT_NE(svgStopDeclaration, nullptr);
558 auto gradientColor = svgStopDeclaration->GetGradientColor();
559 EXPECT_FLOAT_EQ(gradientColor.GetOpacity(), STOP_OPACITY);
560 EXPECT_STREQ(gradientColor.GetColor().ColorToString().c_str(), Color::FromRGB(255, 255, 0).ColorToString().c_str());
561 Testing::MockCanvas rSCanvas;
562 CallBack(rSCanvas);
563 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
564 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
565 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
566 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
567 }
568
569 /**
570 * @tc.name: ParseRectTest001
571 * @tc.desc: parse rect label
572 * @tc.type: FUNC
573 */
574 HWTEST_F(ParseTestNg, ParseRectTest001, TestSize.Level1)
575 {
576 auto svgDom = ParseRect(RECT_SVG_LABEL);
577 Testing::MockCanvas rSCanvas;
578 CallBack(rSCanvas);
579 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
580 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
581 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
582 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
583 }
584
585 /**
586 * @tc.name: ParseRectTest002
587 * @tc.desc: parse rect label
588 * @tc.type: FUNC
589 */
590 HWTEST_F(ParseTestNg, ParseRectTest002, TestSize.Level1)
591 {
592 auto svgDom = ParseRect(RECT_SVG_LABEL);
593 Testing::MockCanvas rSCanvas;
594 CallBack(rSCanvas);
595 svgDom->svgContext_ = nullptr;
596 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
597 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
598 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
599 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
600 }
601
602 /**
603 * @tc.name: ParseRectTest003
604 * @tc.desc: parse rect label
605 * @tc.type: FUNC
606 */
607 HWTEST_F(ParseTestNg, ParseRectTest003, TestSize.Level1)
608 {
609 auto svgDom = ParseRect(RECT_SVG_LABEL2);
610 Testing::MockCanvas rSCanvas;
611 CallBack(rSCanvas);
612 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
613 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
614 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
615 }
616
617 /**
618 * @tc.name: ParsePolygonTest001
619 * @tc.desc: parse polygon and polyline label
620 * @tc.type: FUNC
621 */
622 HWTEST_F(ParseTestNg, ParsePolygonTest001, TestSize.Level1)
623 {
624 auto svgDom = parsePolygon(POLYGON_SVG_LABEL1);
625 Testing::MockCanvas rSCanvas;
626 CallBack(rSCanvas);
627 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
628 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
629 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
630 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
631 }
632
633 /**
634 * @tc.name: ParsePolygonTest001
635 * @tc.desc: parse polygon and polyline label
636 * @tc.type: FUNC
637 */
638 HWTEST_F(ParseTestNg, ParsePolygonTest002, TestSize.Level1)
639 {
640 auto svgDom = parsePolygon(POLYGON_SVG_LABEL2);
641 Testing::MockCanvas rSCanvas;
642 CallBack(rSCanvas);
643 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
644 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
645 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
646 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
647 }
648
649 /**
650 * @tc.name: ParsePatternTest001
651 * @tc.desc: parse pattern label
652 * @tc.type: FUNC
653 */
654 HWTEST_F(ParseTestNg, ParsePatternTest001, TestSize.Level1)
655 {
656 auto svgStream = SkMemoryStream::MakeCopy(PATTERN_SVG_LABEL.c_str(), PATTERN_SVG_LABEL.length());
657 EXPECT_NE(svgStream, nullptr);
658 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
659 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
660 EXPECT_GT(svg->children_.size(), 0);
661 auto svgDefs = AceType::DynamicCast<SvgDefs>(svg->children_.at(0));
662 EXPECT_NE(svgDefs, nullptr);
663 auto svgPattern = AceType::DynamicCast<SvgPattern>(svgDefs->children_.at(0));
664 EXPECT_NE(svgPattern, nullptr);
665 auto patternDeclaration = AceType::DynamicCast<SvgPatternDeclaration>(svgPattern->declaration_);
666 EXPECT_NE(patternDeclaration, nullptr);
667 EXPECT_FLOAT_EQ(patternDeclaration->GetWidth().ConvertToPx(), PATTERN_WIDTH);
668 EXPECT_FLOAT_EQ(patternDeclaration->GetHeight().ConvertToPx(), PATTERN_HEIGHT);
669 EXPECT_FLOAT_EQ(patternDeclaration->GetViewBox().GetOffset().GetX(), PATTERN_VIEWBOX_X);
670 EXPECT_FLOAT_EQ(patternDeclaration->GetViewBox().GetOffset().GetY(), PATTERN_VIEWBOX_Y);
671 EXPECT_FLOAT_EQ(patternDeclaration->GetViewBox().GetSize().Width(), PATTERN_VIEWBOX_WIDTH);
672 EXPECT_FLOAT_EQ(patternDeclaration->GetViewBox().GetSize().Height(), PATTERN_VIEWBOX_HEIGHT);
673 Testing::MockCanvas rSCanvas;
674 CallBack(rSCanvas);
675 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
676 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
677 EXPECT_EQ(svgDom->svgSize_.IsValid(), false);
678 EXPECT_EQ(svgDom->viewBox_.IsValid(), true);
679
680 BorderRadiusArray radius;
681 for (auto&& corner : radius) {
682 corner = { 0.0f, 0.0f };
683 }
684 svgDom->SetRadius(radius);
685 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
686 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
687 EXPECT_EQ(*svgDom->radius_, radius);
688 }
689
690 /**
691 * @tc.name: ParsePathTest001
692 * @tc.desc: parse path label
693 * @tc.type: FUNC
694 */
695 HWTEST_F(ParseTestNg, ParsePathTest001, TestSize.Level1)
696 {
697 auto svgDom = ParsePath(PATH_SVG_LABEL1);
698 Testing::MockCanvas rSCanvas;
699 CallBack(rSCanvas);
700 svgDom->FitViewPort(Size());
701 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
702 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
703 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
704 }
705
706 /**
707 * @tc.name: ParsePathTest002
708 * @tc.desc: parse path label
709 * @tc.type: FUNC
710 */
711
712 HWTEST_F(ParseTestNg, ParsePathTest002, TestSize.Level1)
713 {
714 auto svgDom = ParsePath(PATH_SVG_LABEL2);
715 Testing::MockCanvas rSCanvas;
716 CallBack(rSCanvas);
717 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
718 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
719 EXPECT_EQ(svgDom->svgSize_.IsValid(), false);
720 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
721 }
722
723 /**
724 * @tc.name: ParsePathTest003
725 * @tc.desc: parse path label
726 * @tc.type: FUNC
727 */
728
729 HWTEST_F(ParseTestNg, ParsePathTest003, TestSize.Level1)
730 {
731 auto svgDom = ParsePath(PATH_SVG_LABEL4);
732 Testing::MockCanvas rSCanvas;
733 CallBack(rSCanvas);
734 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
735 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
736 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
737 EXPECT_EQ(svgDom->viewBox_.IsValid(), true);
738 }
739
740 /**
741 * @tc.name: ParsePathTest004
742 * @tc.desc: parse path label
743 * @tc.type: FUNC
744 */
745
746 HWTEST_F(ParseTestNg, ParsePathTest004, TestSize.Level1)
747 {
748 auto svgDom = ParsePath(PATH_SVG_LABEL3);
749 Testing::MockCanvas rSCanvas;
750 CallBack(rSCanvas);
751 svgDom->FitViewPort(Size());
752 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
753 EXPECT_EQ(svgDom->svgSize_.IsValid(), false);
754 EXPECT_EQ(svgDom->viewBox_.IsValid(), true);
755 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
756 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
757 EXPECT_EQ(svgDom->svgSize_.IsValid(), false);
758 EXPECT_EQ(svgDom->viewBox_.IsValid(), true);
759 }
760
761 /**
762 * @tc.name: ParsePathTest005
763 * @tc.desc: parse path label
764 * @tc.type: FUNC
765 */
766
767 HWTEST_F(ParseTestNg, ParsePathTest005, TestSize.Level1)
768 {
769 auto svgDom = ParsePath(PATH_SVG_LABEL5);
770 Testing::MockCanvas rSCanvas;
771 CallBack(rSCanvas);
772 svgDom->FitViewPort(Size());
773 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
774 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
775 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
776 }
777
778 /**
779 * @tc.name: ParseTest001
780 * @tc.desc: parse Mask label
781 * @tc.type: FUNC
782 */
783 HWTEST_F(ParseTestNg, ParseMaskTest001, TestSize.Level1)
784 {
785 auto svgStream = SkMemoryStream::MakeCopy(MASK_SVG_LABEL.c_str(), MASK_SVG_LABEL.length());
786 EXPECT_NE(svgStream, nullptr);
787 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
788 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
789 EXPECT_GT(svg->children_.size(), 0);
790 auto svgG = AceType::DynamicCast<SvgG>(svg->children_.at(INDEX_ONE));
791 EXPECT_NE(svgG, nullptr);
792 auto svgGChild = AceType::DynamicCast<SvgG>(svgG->children_.at(INDEX_ZEARO));
793 EXPECT_NE(svgGChild, nullptr);
794 auto svgMask = AceType::DynamicCast<SvgMask>(svgGChild->children_.at(INDEX_ZEARO));
795 EXPECT_NE(svgMask, nullptr);
796 EXPECT_STREQ(svgMask->nodeId_.c_str(), MASK_ID.c_str());
797 Testing::MockCanvas rSCanvas;
798 CallBack(rSCanvas);
799 // test canvas layer save and restore
800 // all saved layers need to be restored
801 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
802 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
803 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
804 EXPECT_EQ(svgDom->viewBox_.IsValid(), true);
805 }
806
807 /**
808 * @tc.name: ParseLineTest001
809 * @tc.desc: parse line label
810 * @tc.type: FUNC
811 */
812 HWTEST_F(ParseTestNg, ParseLineTest001, TestSize.Level1)
813 {
814 auto svgStream = SkMemoryStream::MakeCopy(LINE_SVG_LABEL.c_str(), LINE_SVG_LABEL.length());
815 EXPECT_NE(svgStream, nullptr);
816 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
817 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
818 EXPECT_GT(svg->children_.size(), 0);
819 auto svgLine = AceType::DynamicCast<SvgLine>(svg->children_.at(0));
820 EXPECT_NE(svgLine, nullptr);
821 auto lineDeclaration = AceType::DynamicCast<SvgLineDeclaration>(svgLine->declaration_);
822 EXPECT_FLOAT_EQ(lineDeclaration->GetX1().ConvertToPx(), X1);
823 EXPECT_FLOAT_EQ(lineDeclaration->GetY1().ConvertToPx(), Y1);
824 EXPECT_FLOAT_EQ(lineDeclaration->GetX2().ConvertToPx(), X2);
825 EXPECT_FLOAT_EQ(lineDeclaration->GetY2().ConvertToPx(), Y2);
826 Testing::MockCanvas rSCanvas;
827 CallBack(rSCanvas);
828 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
829 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
830 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
831 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
832 }
833
834 /**
835 * @tc.name: ParseLinearGradientTest001
836 * @tc.desc: parse lineargradient label
837 * @tc.type: FUNC
838 */
839 HWTEST_F(ParseTestNg, ParseLinearGradientTest001, TestSize.Level1)
840 {
841 auto svgStream = SkMemoryStream::MakeCopy(GRADIENT_SVG_LINEAR.c_str(), GRADIENT_SVG_LINEAR.length());
842 EXPECT_NE(svgStream, nullptr);
843 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
844 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
845 EXPECT_EQ(static_cast<int32_t>(svg->children_.size()), CHILD_NUMBER);
846 auto defers = AceType::DynamicCast<SvgDefs>(svg->children_.at(INDEX_ZEARO));
847 EXPECT_NE(defers, nullptr);
848 EXPECT_NE(defers->children_.at(INDEX_ZEARO), nullptr);
849 auto svgGradient = AceType::DynamicCast<SvgGradient>(defers->children_.at(INDEX_ZEARO));
850 EXPECT_NE(svgGradient, nullptr);
851 auto svgGradientDeclaration = AceType::DynamicCast<SvgGradientDeclaration>(svgGradient->gradientDeclaration_);
852 EXPECT_NE(svgGradientDeclaration, nullptr);
853 auto gradient = svgGradientDeclaration->GetGradient();
854 EXPECT_EQ(gradient.GetLinearGradient().x1.has_value(), true);
855 EXPECT_FLOAT_EQ(gradient.GetLinearGradient().x1->ConvertToPx(), ZERO);
856 EXPECT_EQ(gradient.GetLinearGradient().x2.has_value(), true);
857 EXPECT_FLOAT_EQ(gradient.GetLinearGradient().x2->ConvertToPx(), ZERO);
858 EXPECT_EQ(gradient.GetLinearGradient().y1.has_value(), true);
859 EXPECT_FLOAT_EQ(gradient.GetLinearGradient().y1->ConvertToPx(), ZERO);
860 EXPECT_EQ(gradient.GetLinearGradient().y2.has_value(), true);
861 EXPECT_FLOAT_EQ(gradient.GetLinearGradient().y2->ConvertToPx(), ZERO);
862 Testing::MockCanvas rSCanvas;
863 CallBack(rSCanvas);
864 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
865 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
866 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
867 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
868 }
869
870 /**
871 * @tc.name: ParseRadialGradientTest001
872 * @tc.desc: parse radialgradient label
873 * @tc.type: FUNC
874 */
875 HWTEST_F(ParseTestNg, ParseRadialGradientTest001, TestSize.Level1)
876 {
877 auto svgStream = SkMemoryStream::MakeCopy(GRADIENT_SVG_RADIAL.c_str(), GRADIENT_SVG_RADIAL.length());
878 EXPECT_NE(svgStream, nullptr);
879 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
880 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
881 EXPECT_EQ(svg->children_.size(), CHILD_NUMBER);
882 auto defers = AceType::DynamicCast<SvgDefs>(svg->children_.at(INDEX_ZEARO));
883 EXPECT_NE(defers, nullptr);
884 EXPECT_NE(defers->children_.at(INDEX_ZEARO), nullptr);
885 auto svgGradient = AceType::DynamicCast<SvgGradient>(defers->children_.at(INDEX_ZEARO));
886 EXPECT_NE(svgGradient, nullptr);
887 auto svgGradientDeclaration = AceType::DynamicCast<SvgGradientDeclaration>(svgGradient->gradientDeclaration_);
888 EXPECT_NE(svgGradientDeclaration, nullptr);
889 auto gradient = svgGradientDeclaration->GetGradient();
890 auto radialGradient = gradient.GetRadialGradient();
891 EXPECT_EQ(radialGradient.fRadialCenterX.has_value(), true);
892 EXPECT_FLOAT_EQ(radialGradient.fRadialCenterX->ConvertToPx(), ZERO);
893 EXPECT_EQ(radialGradient.fRadialCenterY.has_value(), true);
894 EXPECT_FLOAT_EQ(radialGradient.fRadialCenterY->ConvertToPx(), ZERO);
895 EXPECT_EQ(radialGradient.radialCenterX.has_value(), true);
896 EXPECT_FLOAT_EQ(radialGradient.radialCenterX->ConvertToPx(), ZERO);
897 EXPECT_EQ(radialGradient.radialCenterY.has_value(), true);
898 EXPECT_FLOAT_EQ(radialGradient.radialCenterY->ConvertToPx(), ZERO);
899 EXPECT_EQ(radialGradient.radialHorizontalSize.has_value(), true);
900 EXPECT_FLOAT_EQ(radialGradient.radialHorizontalSize->ConvertToPx(), ZERO);
901 EXPECT_EQ(radialGradient.radialVerticalSize.has_value(), true);
902 EXPECT_FLOAT_EQ(radialGradient.radialVerticalSize->ConvertToPx(), ZERO);
903 EXPECT_EQ(radialGradient.radialShape.has_value(), false);
904 EXPECT_EQ(radialGradient.radialSizeType.has_value(), false);
905 Testing::MockCanvas rSCanvas;
906 CallBack(rSCanvas);
907 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
908 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
909 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
910 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
911 }
912
913 /**
914 * @tc.name: ParseGTest001
915 * @tc.desc: parse g label
916 * @tc.type: FUNC
917 */
918 HWTEST_F(ParseTestNg, ParseGTest001, TestSize.Level1)
919 {
920 auto svgStream = SkMemoryStream::MakeCopy(G_SVG_LABEL.c_str(), G_SVG_LABEL.length());
921 EXPECT_NE(svgStream, nullptr);
922 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
923 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
924 EXPECT_GT(svg->children_.size(), 0);
925 auto g = AceType::DynamicCast<SvgG>(svg->children_.at(0));
926 ASSERT_STREQ(g->nodeId_.c_str(), G_ID.c_str());
927 Testing::MockCanvas rSCanvas;
928 EXPECT_CALL(rSCanvas, AttachBrush(_)).WillRepeatedly(ReturnRef(rSCanvas));
929 EXPECT_CALL(rSCanvas, DetachBrush()).WillRepeatedly(ReturnRef(rSCanvas));
930 EXPECT_CALL(rSCanvas, AttachPen(_)).WillRepeatedly(ReturnRef(rSCanvas));
931 EXPECT_CALL(rSCanvas, DetachPen()).WillRepeatedly(ReturnRef(rSCanvas));
932 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
933 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
934 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
935 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
936 }
937
938 /**
939 * @tc.name: ParseFilterTest001
940 * @tc.desc: parse filter label
941 * @tc.type: FUNC
942 */
943 HWTEST_F(ParseTestNg, ParseFilterTest001, TestSize.Level1)
944 {
945 auto svgStream = SkMemoryStream::MakeCopy(FILTER_SVG_LABEL.c_str(), FILTER_SVG_LABEL.length());
946 EXPECT_NE(svgStream, nullptr);
947 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
948 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
949 EXPECT_GT(svg->children_.size(), 0);
950 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
951 EXPECT_STREQ(svgFilter->nodeId_.c_str(), FILTER_ID.c_str());
952 auto filterDeclaration = AceType::DynamicCast<SvgFilterDeclaration>(svgFilter->declaration_);
953 EXPECT_NE(filterDeclaration, nullptr);
954 EXPECT_FLOAT_EQ(filterDeclaration->GetHeight().ConvertToPx(), FILTER_HEIGHT);
955 EXPECT_FLOAT_EQ(filterDeclaration->GetWidth().ConvertToPx(), FILTER_WIDTH);
956 EXPECT_FLOAT_EQ(filterDeclaration->GetX().ConvertToPx(), ZERO);
957 EXPECT_FLOAT_EQ(filterDeclaration->GetY().ConvertToPx(), ZERO);
958 Testing::MockCanvas rSCanvas;
959 CallBack(rSCanvas);
960 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
961 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
962 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
963 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
964 }
965
966 /**
967 * @tc.name: ParseFeGaussianblurTest001
968 * @tc.desc: parse Fegaussianblur label
969 * @tc.type: FUNC
970 */
971 HWTEST_F(ParseTestNg, ParseFeGaussianblurTest001, TestSize.Level1)
972 {
973 auto svgDom = ParseFeGaussianblur(FEGAUSS_SVG_LABEL);
974 Testing::MockCanvas rSCanvas;
975 CallBack(rSCanvas);
976 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
977 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
978 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
979 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
980 }
981
982 /**
983 * @tc.name: ParseFeGaussianblurTest002
984 * @tc.desc: parse Fegaussianblur label svg size is invalid
985 * @tc.type: FUNC
986 */
987 HWTEST_F(ParseTestNg, ParseFeGaussianblurTest002, TestSize.Level1)
988 {
989 auto svgDom = ParseFeGaussianblur(FEGAUSS_SVG_LABEL2);
990 Testing::MockCanvas rSCanvas;
991 CallBack(rSCanvas);
992 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
993 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
994 EXPECT_EQ(svgDom->svgSize_.IsValid(), false);
995 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
996 }
997
998 /**
999 * @tc.name: ParseFeCompositeTest001
1000 * @tc.desc: parse FeComposite label
1001 * @tc.type: FUNC
1002 */
1003 HWTEST_F(ParseTestNg, ParseFeCompositeTest001, TestSize.Level1)
1004 {
1005 auto svgStream = SkMemoryStream::MakeCopy(COMPOSITE_SVG_LABEL.c_str(), COMPOSITE_SVG_LABEL.length());
1006 EXPECT_NE(svgStream, nullptr);
1007 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
1008 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1009 EXPECT_GT(svg->children_.size(), 0);
1010 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
1011 EXPECT_NE(svgFilter, nullptr);
1012 auto svgFeComposite = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(0));
1013 EXPECT_NE(svgFeComposite, nullptr);
1014 auto feCompositsDeclaration = AceType::DynamicCast<SvgFeCompositeDeclaration>(svgFeComposite->declaration_);
1015 EXPECT_NE(feCompositsDeclaration, nullptr);
1016 Testing::MockCanvas rSCanvas;
1017 CallBack(rSCanvas);
1018 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1019 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
1020 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
1021 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
1022 }
1023
1024 /**
1025 * @tc.name: ParseFeCompositeTest002
1026 * @tc.desc: parse Fe label
1027 * @tc.type: FUNC
1028 */
1029 HWTEST_F(ParseTestNg, ParseFeCompositeTest002, TestSize.Level1)
1030 {
1031 SvgFe* svgFe = new SvgFe();
1032 EXPECT_NE(svgFe, nullptr);
1033 #ifndef USE_ROSEN_DRAWING
1034 sk_sp<SkImageFilter> imageFilter = nullptr;
1035 #else
1036 std::shared_ptr<RSImageFilter> imageFilter = nullptr;
1037 #endif
1038 ColorInterpolationType colorInterpolationType = ColorInterpolationType::LINEAR_RGB;
1039 ColorInterpolationType srcColor = ColorInterpolationType::SRGB;
1040 svgFe->GetImageFilter(imageFilter, colorInterpolationType);
1041 EXPECT_EQ(colorInterpolationType, ColorInterpolationType::LINEAR_RGB);
1042 svgFe->ConverImageFilterColor(imageFilter, srcColor, colorInterpolationType);
1043 EXPECT_NE(imageFilter, nullptr);
1044 EXPECT_EQ(colorInterpolationType, ColorInterpolationType::LINEAR_RGB);
1045 delete svgFe;
1046 }
1047
1048 /**
1049 * @tc.name: ParseFeCompositeTest003
1050 * @tc.desc: parse FeColorMatrix label
1051 * @tc.type: FUNC
1052 */
1053 HWTEST_F(ParseTestNg, ParseFeCompositeTest003, TestSize.Level1)
1054 {
1055 SvgFeColorMatrix* colorMatrix = new SvgFeColorMatrix();
1056 EXPECT_NE(colorMatrix, nullptr);
1057 colorMatrix->OnInitStyle();
1058 #ifndef USE_ROSEN_DRAWING
1059 sk_sp<SkImageFilter> imageFilter = nullptr;
1060 #else
1061 std::shared_ptr<RSImageFilter> imageFilter = nullptr;
1062 #endif
1063 ColorInterpolationType srcColor = ColorInterpolationType::SRGB;
1064 ColorInterpolationType colorInterPolationType = ColorInterpolationType::LINEAR_RGB;
1065 colorMatrix->OnAsImageFilter(imageFilter, srcColor, colorInterPolationType);
1066 EXPECT_NE(imageFilter, nullptr);
1067 EXPECT_EQ(colorInterPolationType, ColorInterpolationType::LINEAR_RGB);
1068 EXPECT_EQ(srcColor, ColorInterpolationType::SRGB);
1069 delete colorMatrix;
1070 }
1071
1072 /**
1073 * @tc.name: ParseFeColorMatrixTest001
1074 * @tc.desc: parse FeColorMatrix label
1075 * @tc.type: FUNC
1076 */
1077 HWTEST_F(ParseTestNg, ParseFeColorMatrixTest001, TestSize.Level1)
1078 {
1079 auto svgStream = SkMemoryStream::MakeCopy(COLOR_MATRIX_SVG_LABEL.c_str(), COLOR_MATRIX_SVG_LABEL.length());
1080 EXPECT_NE(svgStream, nullptr);
1081 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
1082 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1083 EXPECT_GT(svg->children_.size(), 0);
1084 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
1085 EXPECT_NE(svgFilter, nullptr);
1086 auto svgFeColorMatrix = AceType::DynamicCast<SvgFeColorMatrix>(svgFilter->children_.at(0));
1087 EXPECT_NE(svgFeColorMatrix, nullptr);
1088 auto feColorDeclaration = AceType::DynamicCast<SvgFeColorMatrixDeclaration>(svgFeColorMatrix->declaration_);
1089 EXPECT_NE(feColorDeclaration, nullptr);
1090 EXPECT_STREQ(feColorDeclaration->GetType().c_str(), TYPE.c_str());
1091 EXPECT_STREQ(feColorDeclaration->GetValues().c_str(), VALUE.c_str());
1092 Testing::MockCanvas rSCanvas;
1093 CallBack(rSCanvas);
1094 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1095 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
1096 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
1097 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
1098 }
1099
1100 /**
1101 * @tc.name: ParseEllipseTest001
1102 * @tc.desc: parse ellipse label
1103 * @tc.type: FUNC
1104 */
1105 HWTEST_F(ParseTestNg, ParseEllipseTest001, TestSize.Level1)
1106 {
1107 auto svgDom = ParseEllipse(ELLIPSE_SVG_LABEL1);
1108 Testing::MockCanvas rSCanvas;
1109 CallBack(rSCanvas);
1110 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1111 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
1112 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
1113 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
1114 }
1115
1116 /**
1117 * @tc.name: ParseEllipseTest002
1118 * @tc.desc: parse ellipse label
1119 * @tc.type: FUNC
1120 */
1121 HWTEST_F(ParseTestNg, ParseEllipseTest002, TestSize.Level1)
1122 {
1123 auto svgDom = ParseEllipse(ELLIPSE_SVG_LABEL2);
1124 Testing::MockCanvas rSCanvas;
1125 CallBack(rSCanvas);
1126 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1127 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
1128 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
1129 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
1130 }
1131
1132 /**
1133 * @tc.name: ParseEllipseTest003
1134 * @tc.desc: parse ellipse label
1135 * @tc.type: FUNC
1136 */
1137 HWTEST_F(ParseTestNg, ParseEllipseTest003, TestSize.Level1)
1138 {
1139 auto svgDom = ParseEllipse(ELLIPSE_SVG_LABEL2);
1140 Testing::MockCanvas rSCanvas;
1141 EXPECT_CALL(rSCanvas, AttachBrush(_)).WillRepeatedly(ReturnRef(rSCanvas));
1142 EXPECT_CALL(rSCanvas, DetachBrush()).WillRepeatedly(ReturnRef(rSCanvas));
1143 EXPECT_CALL(rSCanvas, AttachPen(_)).WillRepeatedly(ReturnRef(rSCanvas));
1144 EXPECT_CALL(rSCanvas, DetachPen()).WillRepeatedly(ReturnRef(rSCanvas));
1145 svgDom->root_ = nullptr;
1146 svgDom->FitViewPort(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1147 EXPECT_EQ(svgDom->svgSize_.IsValid(), true);
1148 EXPECT_EQ(svgDom->viewBox_.IsValid(), false);
1149 }
1150
1151 /**
1152 * @tc.name: ParseEllipseTest004
1153 * @tc.desc: parse ellipse label
1154 * @tc.type: FUNC
1155 */
1156 HWTEST_F(ParseTestNg, ParseEllipseTest004, TestSize.Level1)
1157 {
1158 SvgEllipse* sEllipse = new SvgEllipse();
1159 const Size viewPort = Size(0.0, 0.0);
1160 EXPECT_EQ(viewPort.Width(), 0.0);
1161 EXPECT_EQ(viewPort.Height(), 0.0);
1162 auto svgEllipse1 = sEllipse->Create();
1163 svgEllipse1->AsPath(viewPort);
1164 delete sEllipse;
1165 }
1166
1167 /**
1168 * @tc.name: ParseAnimateTest001
1169 * @tc.desc: parse circle label
1170 * @tc.type: FUNC
1171 */
1172 HWTEST_F(ParseTestNg, ParseAnimateTest001, TestSize.Level1)
1173 {
1174 auto svgStream = SkMemoryStream::MakeCopy(SVG_ANIMATE_TRANSFORM.c_str(), SVG_ANIMATE_TRANSFORM.length());
1175 EXPECT_NE(svgStream, nullptr);
1176 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
1177 EXPECT_TRUE(svgDom);
1178 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1179 EXPECT_TRUE(svg);
1180 EXPECT_GT(svg->children_.size(), 0);
1181
1182 auto svgAnimate = AceType::DynamicCast<SvgAnimation>(svg->children_.at(0)->children_.at(0));
1183 EXPECT_TRUE(svgAnimate);
1184 // values changed to indices
1185 std::vector<std::string> values { "0", "1", "2" };
1186 EXPECT_EQ(svgAnimate->GetValues(), values);
1187 }
1188
1189 /**
1190 * @tc.name: ParseAnimation002
1191 * @tc.desc: Create Animation SvgAnimateType:MOTION
1192 * @tc.type: FUNC
1193 */
1194 HWTEST_F(ParseTestNg, ParseAnimation002, TestSize.Level1)
1195 {
1196 auto svgAnimation = AccessibilityManager::MakeRefPtr<SvgAnimation>(SvgAnimateType::MOTION);
1197 auto svgMotion = svgAnimation->CreateAnimateMotion();
1198 EXPECT_NE(svgAnimation, nullptr);
1199
1200 /* *
1201 * @tc.steps: step1. call SetAttr UpdateAttr
1202 * @tc.expected: Execute function return value is CalcMode::DISCRETE
1203 */
1204 svgAnimation->SetAttr("fill", "red");
1205 svgAnimation->UpdateAttr();
1206 EXPECT_EQ(svgAnimation->ConvertCalcMode("discrete"), CalcMode::DISCRETE);
1207
1208 /* *
1209 * @tc.steps: step2. call CreatePropertyAnimation
1210 * @tc.expected: Execute function return value is false
1211 */
__anon4092927c0202(double x) 1212 std::function<void(double)> callback = [](double x) -> void { x = 0; };
1213 const double value = 0;
1214 svgAnimation->CreatePropertyAnimation<double>(value, std::move(callback));
1215 EXPECT_EQ(svgAnimation->animator_->IsStopped(), false);
1216 }
1217
1218 /**
1219 * @tc.name: ParseCircleTest002
1220 * @tc.desc: Circle Set Animation Runtime Parameters
1221 * @tc.type: FUNC
1222 */
1223 HWTEST_F(ParseTestNg, ParseCircleTest002, TestSize.Level1)
1224 {
1225 auto svgCircle = AccessibilityManager::MakeRefPtr<SvgCircle>();
1226 EXPECT_NE(svgCircle, nullptr);
1227 auto svgAnimation = AccessibilityManager::MakeRefPtr<SvgAnimation>(SvgAnimateType::ANIMATE);
1228
1229 /* *
1230 * @tc.steps: step1. call PrepareAnimation
1231 * @tc.expected: Execute function return value is cx cy
1232 */
1233 svgCircle->PrepareAnimation(svgAnimation);
1234 EXPECT_NE(svgAnimation, nullptr);
1235
1236 svgAnimation->SetAttr("attributeName", "cx");
1237 svgAnimation->UpdateAttr();
1238 EXPECT_EQ(svgAnimation->GetAttributeName(), "cx");
1239
1240 svgCircle->PrepareAnimation(svgAnimation);
1241 svgAnimation->SetAttr("attributeName", "cy");
1242 svgAnimation->UpdateAttr();
1243 EXPECT_EQ(svgAnimation->GetAttributeName(), "cy");
1244
1245 svgCircle->PrepareAnimation(svgAnimation);
1246 EXPECT_EQ(svgAnimation->GetAttributeName(), "cy");
1247
1248 /* *
1249 * @tc.steps: step2. call SetAttr UpdateAttr
1250 * @tc.expected: Execute function return value is r
1251 */
1252 svgAnimation->SetAttr("attributeName", "r");
1253 svgAnimation->UpdateAttr();
1254 EXPECT_EQ(svgAnimation->GetAttributeName(), "r");
1255
1256 /* *
1257 * @tc.steps: step3. SetCalcMode
1258 * @tc.expected: Execute function return value is 10
1259 */
1260 svgAnimation->SetCalcMode(static_cast<CalcMode>(10));
1261 svgCircle->PrepareAnimation(svgAnimation);
1262 EXPECT_EQ(static_cast<int>(svgAnimation->GetCalcMode()), 10);
1263 }
1264
1265 /**
1266 * @tc.name: ParseFeCompositeTest004
1267 * @tc.desc: Create SvgFe obj
1268 * @tc.type: FUNC
1269 */
1270 HWTEST_F(ParseTestNg, ParseFeCompositeTest004, TestSize.Level1)
1271 {
1272 /* *
1273 * @tc.steps: step1. call GetImageFilter
1274 * @tc.expected: Execute function return value is ColorInterpolationType::SRGB
1275 */
1276 auto svgFe = AccessibilityManager::MakeRefPtr<SvgFe>();
1277 std::shared_ptr<RSImageFilter> imageFilter = nullptr;
1278 ColorInterpolationType colorInterpolationType = ColorInterpolationType::SRGB;
1279 ColorInterpolationType srcColor = ColorInterpolationType::LINEAR_RGB;
1280 svgFe->GetImageFilter(imageFilter, colorInterpolationType);
1281 EXPECT_EQ(colorInterpolationType, ColorInterpolationType::SRGB);
1282
1283 /* *
1284 * @tc.steps: step3. call GetImageFilter
1285 * @tc.expected: Execute function return value is ColorInterpolationType::SRGB
1286 */
1287 svgFe->ConverImageFilterColor(imageFilter, srcColor, colorInterpolationType);
1288 EXPECT_NE(imageFilter, nullptr);
1289 EXPECT_EQ(colorInterpolationType, ColorInterpolationType::SRGB);
1290 }
1291
1292 /**
1293 * @tc.name: ParseFeCompositeTest005
1294 * @tc.desc: Create SvgFe obj
1295 * @tc.type: FUNC
1296 */
1297 HWTEST_F(ParseTestNg, ParseFeCompositeTest005, TestSize.Level1)
1298 {
1299 /* *
1300 * @tc.steps: step1. call MakeRefPtr<SvgFe>()
1301 * @tc.expected: Execute function return value not is nullptr
1302 */
1303 auto svgFe = AccessibilityManager::MakeRefPtr<SvgFe>();
1304 EXPECT_NE(svgFe, nullptr);
1305
1306 /* *
1307 * @tc.steps: step2. call MakeImageFilter
1308 * @tc.expected: Execute function return value not is nullptr
1309 */
1310 std::shared_ptr<RSImageFilter> imageFilter = nullptr;
1311 auto value = svgFe->MakeImageFilter(FeInType::SOURCE_GRAPHIC, imageFilter);
1312 EXPECT_EQ(value, nullptr);
1313
1314 value = svgFe->MakeImageFilter(FeInType::SOURCE_ALPHA, imageFilter);
1315 EXPECT_NE(value, nullptr);
1316
1317 value = svgFe->MakeImageFilter(FeInType::BACKGROUND_IMAGE, imageFilter);
1318 EXPECT_EQ(value, nullptr);
1319
1320 value = svgFe->MakeImageFilter(FeInType::BACKGROUND_ALPHA, imageFilter);
1321 EXPECT_EQ(value, nullptr);
1322
1323 value = svgFe->MakeImageFilter(FeInType::FILL_PAINT, imageFilter);
1324 EXPECT_EQ(value, nullptr);
1325
1326 value = svgFe->MakeImageFilter(FeInType::STROKE_PAINT, imageFilter);
1327 EXPECT_EQ(value, nullptr);
1328
1329 value = svgFe->MakeImageFilter(FeInType::PRIMITIVE, imageFilter);
1330 EXPECT_EQ(value, nullptr);
1331
1332 // 20 = Values not in definition
1333 int cnt = 20;
1334 value = svgFe->MakeImageFilter(static_cast<FeInType>(cnt), imageFilter);
1335 EXPECT_EQ(value, nullptr);
1336 }
1337
1338 /**
1339 * @tc.name: ParseNodeTest001
1340 * @tc.desc: SvgSvg Set Animation Runtime Parameters
1341 * @tc.type: FUNC
1342 */
1343 HWTEST_F(ParseTestNg, ParseNodeTest001, TestSize.Level1)
1344 {
1345 auto svg = SvgSvg::Create();
1346 EXPECT_NE(svg, nullptr);
1347 auto svgAnimation = AccessibilityManager::MakeRefPtr<SvgAnimation>(SvgAnimateType::ANIMATE);
1348 svg->PrepareAnimation(svgAnimation);
1349 EXPECT_NE(svgAnimation, nullptr);
1350
1351 /* *
1352 * @tc.steps: step1. call SetAttr UpdateAttr
1353 * @tc.expected: Execute function return value is fill stroke-width
1354 */
1355 svgAnimation->SetAttr("attributeName", "fill");
1356 svgAnimation->UpdateAttr();
1357 svg->PrepareAnimation(svgAnimation);
1358 EXPECT_EQ(svgAnimation->GetAttributeName(), "fill");
1359
1360 svgAnimation->SetAttr("attributeName", "stroke-width");
1361 svgAnimation->UpdateAttr();
1362 svg->PrepareAnimation(svgAnimation);
1363 EXPECT_EQ(svgAnimation->GetAttributeName(), "stroke-width");
1364 }
1365
1366 /**
1367 * @tc.name: ParseNodeTest002
1368 * @tc.desc: parse clip path label
1369 * @tc.type: FUNC
1370 */
1371 HWTEST_F(ParseTestNg, ParseNodeTest002, TestSize.Level1)
1372 {
1373 auto svgStream = SkMemoryStream::MakeCopy(CLIP_SVG_LABEL.c_str(), CLIP_SVG_LABEL.length());
1374 EXPECT_NE(svgStream, nullptr);
1375 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
1376 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1377
1378 // 0 = Expected value
1379 EXPECT_GT(svg->children_.size(), 0);
1380
1381 /* *
1382 * @tc.steps: step1. call SetHref InitStyle
1383 * @tc.expected: Execute function return value is 1.
1384 */
1385 svgDom->root_->declaration_->SetHref("href");
1386 svgDom->root_->svgContext_.Upgrade()->Push("href", SvgGradient::CreateLinearGradient());
1387 svgDom->root_->InitStyle(nullptr);
1388 EXPECT_EQ(svgDom->root_->declaration_->GetHref(), "href");
1389 Testing::MockCanvas rSCanvas;
1390 CallBack(rSCanvas);
1391 svgDom->root_->hrefRender_ = false;
1392
1393 // 1 = SmoothEdge
1394 svgDom->root_->SetSmoothEdge(1);
1395 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
1396 EXPECT_EQ(svgDom->root_->GetSmoothEdge(), 1);
1397
1398 /* *
1399 * @tc.steps: step2. call Draw
1400 * @tc.expected: Execute function return value is false.
1401 */
1402 svgDom->root_->hrefMaskId_ = "123";
1403 svgDom->root_->transform_ = "123";
1404 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
1405 svgDom->root_->transform_.clear();
1406 svgDom->root_->animateTransform_["123"] = {0.1, 0.2};
1407 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
1408 EXPECT_FALSE(svgDom->root_->animateTransform_.empty());
1409 }
1410
1411 /**
1412 * @tc.name: ParseNodeTest003
1413 * @tc.desc: parse clip path label
1414 * @tc.type: FUNC
1415 */
1416 HWTEST_F(ParseTestNg, ParseNodeTest003, TestSize.Level1)
1417 {
1418 auto svgStream = SkMemoryStream::MakeCopy(CLIP_SVG_LABEL.c_str(), CLIP_SVG_LABEL.length());
1419 EXPECT_NE(svgStream, nullptr);
1420 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
1421 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1422 EXPECT_GT(svg->children_.size(), 0);
1423
1424 /* *
1425 * @tc.steps: step1. call UpdateAttr UpdateAttrHelper
1426 * @tc.expected: Update incoming parameters, parameters not is empty
1427 */
1428 svg->UpdateAttr("fill", Color::BLACK);
1429 svg->UpdateAttr("fill", Dimension());
1430
1431 // 120.5 = test height value
1432 svg->UpdateAttr("height", 120.5);
1433 svg->passStyle_ = false;
1434 svg->UpdateAttrHelper("fill", "black");
1435 EXPECT_FALSE(svg->declaration_->attributes_.empty());
1436
1437 /* *
1438 * @tc.steps: step2. call ConvertDimensionToPx
1439 * @tc.expected: ConvertDimensionToPx return value not equal 0
1440 */
1441 Size size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT);
1442
1443 // 1.2 = test value
1444 double value = 1.2;
1445
1446 // 1.23 = test value
1447 double value2 = 1.23;
1448
1449 // 0 = expect test value
1450 int cnt = 0;
1451 Dimension dime(value, DimensionUnit::PERCENT);
1452 double value3 = svg->ConvertDimensionToPx(dime, size, SvgLengthType::HORIZONTAL);
1453 EXPECT_NE(value3, cnt);
1454
1455 value3 = svg->ConvertDimensionToPx(dime, size, SvgLengthType::VERTICAL);
1456 EXPECT_NE(value3, cnt);
1457
1458 value3 = svg->ConvertDimensionToPx(dime, size, SvgLengthType::OTHER);
1459 EXPECT_NE(value3, cnt);
1460
1461 value3 = svg->ConvertDimensionToPx(Dimension(value, DimensionUnit::AUTO), size, SvgLengthType::OTHER);
1462 EXPECT_EQ(value3, cnt);
1463
1464 value3 = svg->ConvertDimensionToPx(Dimension(value), size, SvgLengthType::OTHER);
1465 EXPECT_NE(value3, cnt);
1466
1467 value3 = svg->ConvertDimensionToPx(Dimension(value), value2);
1468 EXPECT_NE(value3, cnt);
1469
1470 value3 = svg->ConvertDimensionToPx(Dimension(value, DimensionUnit::PERCENT), value2);
1471 EXPECT_NE(value3, cnt);
1472
1473 value3 = svg->ConvertDimensionToPx(Dimension(value, DimensionUnit::AUTO), value2);
1474 EXPECT_NE(value3, value);
1475 }
1476
1477 /**
1478 * @tc.name: ParseNodeTest004
1479 * @tc.desc: Obtaining the ViewBox node of xml
1480 * @tc.type: FUNC
1481 */
1482 HWTEST_F(ParseTestNg, ParseNodeTest004, TestSize.Level1)
1483 {
1484 /* *
1485 * @tc.steps: step1. call GetRootViewBox
1486 * @tc.expected: ViewBox width-value is 0.0
1487 */
1488 auto svg = AccessibilityManager::MakeRefPtr<SvgNode>();
1489 svg->svgContext_ = WeakPtr<SvgContext>();
1490 Rect rect = svg->GetRootViewBox();
1491
1492 // 0.0 = default value
1493 EXPECT_EQ(rect.Left(), 0.0);
1494
1495 /* *
1496 * @tc.steps: step2. call GetRootViewBox
1497 * @tc.expected: ViewBox width-value is 120
1498 */
1499 auto svgStream = SkMemoryStream::MakeCopy(CLIP_SVG_LABEL.c_str(), CLIP_SVG_LABEL.length());
1500 EXPECT_NE(svgStream, nullptr);
1501
1502 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
1503 rect = svgDom->root_->GetRootViewBox();
1504
1505 // 120 = xml ViewBox width-value
1506 EXPECT_EQ(rect.Width(), 120);
1507 }
1508
1509 /**
1510 * @tc.name: ParseNodeTest005
1511 * @tc.desc: Create an animation and set the transition path
1512 * @tc.type: FUNC
1513 */
1514 HWTEST_F(ParseTestNg, ParseNodeTest005, TestSize.Level1)
1515 {
1516 /* *
1517 * @tc.steps: step1. call SetFrom SetTo SetTransformType
1518 * @tc.expected: Execute function return value is "0 60 70", "360 60 70", "rotate"
1519 */
1520 auto svgAnimation = AccessibilityManager::MakeRefPtr<SvgAnimation>(SvgAnimateType::TRANSFORM);
1521 svgAnimation->SetFrom("0 60 70");
1522 EXPECT_EQ(svgAnimation->GetFrom(), "0 60 70");
1523
1524 svgAnimation->SetTo("360 60 70");
1525 EXPECT_EQ(svgAnimation->GetTo(), "360 60 70");
1526
1527 svgAnimation->SetTransformType("rotate");
1528 EXPECT_EQ(svgAnimation->GetTransformType(), "rotate");
1529 EXPECT_NE(svgAnimation, nullptr);
1530
1531 /* *
1532 * @tc.steps: step2. call AnimateTransform
1533 * @tc.expected: Execute function return value not is nullptr
1534 */
1535 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
1536 EXPECT_NE(svgNode, nullptr);
1537
1538 // 0 = test value
1539 svgNode->AnimateTransform(svgAnimation, 0);
1540 auto svgAnimation2 = AccessibilityManager::MakeRefPtr<SvgAnimation>(SvgAnimateType::TRANSFORM);
1541 svgNode->AnimateTransform(svgAnimation2, 0);
1542 EXPECT_NE(svgAnimation2, nullptr);
1543 }
1544
1545 /**
1546 * @tc.name: ParseNodeTest006
1547 * @tc.desc: Create an animation and set the transition path
1548 * @tc.type: FUNC
1549 */
1550 HWTEST_F(ParseTestNg, ParseNodeTest006, TestSize.Level1)
1551 {
1552 /* *
1553 * @tc.steps: step1. call SvgAnimation SvgNode
1554 * @tc.expected: Execute function return value not is nullptr
1555 */
1556 auto svgAnimation = AccessibilityManager::MakeRefPtr<SvgAnimation>(SvgAnimateType::TRANSFORM);
1557 svgAnimation->values_ = { "1", "2" };
1558 EXPECT_NE(svgAnimation, nullptr);
1559 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
1560
1561 // 0 = test value
1562 int cnt = 0;
1563 svgNode->AnimateTransform(svgAnimation, cnt);
1564 EXPECT_NE(svgNode, nullptr);
1565
1566 /* *
1567 * @tc.steps: step2. call AnimateTransform
1568 * @tc.expected: Execute function return value is rotate
1569 */
1570 svgAnimation->values_ = { "1" };
1571 svgAnimation->SetTransformType("rotate");
1572 svgNode->AnimateTransform(svgAnimation, cnt);
1573 EXPECT_EQ(svgAnimation->GetTransformType(), "rotate");
1574 }
1575
1576 /**
1577 * @tc.name: ParseNodeTest007
1578 * @tc.desc: Create an animation and set DrawTraversed
1579 * @tc.type: FUNC
1580 */
1581 HWTEST_F(ParseTestNg, ParseNodeTest007, TestSize.Level1)
1582 {
1583 /* *
1584 * @tc.steps: step1. call GetGradient
1585 * @tc.expected: Execute function return value is false
1586 */
1587 auto svgAnimation = SvgAnimation::Create();
1588 auto op = svgAnimation->GetGradient("");
1589 EXPECT_EQ(op.has_value(), false);
1590
1591 /* *
1592 * @tc.steps: step2. call OnDrawTraversed
1593 * @tc.expected: Execute function return value is false
1594 */
1595 RefPtr<SvgNode> ptr;
1596 svgAnimation->children_ = { ptr, svgAnimation };
1597 Testing::MockCanvas rSCanvas;
1598 EXPECT_CALL(rSCanvas, AttachBrush(_)).WillRepeatedly(ReturnRef(rSCanvas));
1599 EXPECT_CALL(rSCanvas, DetachBrush()).WillRepeatedly(ReturnRef(rSCanvas));
1600 EXPECT_CALL(rSCanvas, AttachPen(_)).WillRepeatedly(ReturnRef(rSCanvas));
1601 EXPECT_CALL(rSCanvas, DetachPen()).WillRepeatedly(ReturnRef(rSCanvas));
1602 svgAnimation->OnDrawTraversed(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
1603 svgAnimation->InitNoneFlag();
1604 svgAnimation->OnDrawTraversed(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
1605 EXPECT_FALSE(svgAnimation->inheritStyle_);
1606 }
1607
1608 /**
1609 * @tc.name: ParseNodeTest008
1610 * @tc.desc: SvgSvg Set Animation Runtime Parameters
1611 * @tc.type: FUNC
1612 */
1613 HWTEST_F(ParseTestNg, ParseNodeTest008, TestSize.Level1)
1614 {
1615 /* *
1616 * @tc.steps: step1. call PrepareAnimation
1617 * @tc.expected: Execute function return value is fill-opacity opacity
1618 */
1619 auto svg = SvgSvg::Create();
1620 EXPECT_NE(svg, nullptr);
1621
1622 auto svgAnimation = AccessibilityManager::MakeRefPtr<SvgAnimation>(SvgAnimateType::ANIMATE);
1623 svg->PrepareAnimation(svgAnimation);
1624 svgAnimation->SetAttr("attributeName", "fill-opacity");
1625 svgAnimation->UpdateAttr();
1626 svg->PrepareAnimation(svgAnimation);
1627 EXPECT_EQ(svgAnimation->GetAttributeName(), "fill-opacity");
1628
1629 svgAnimation->SetAttr("attributeName", "stroke-opacity");
1630 svgAnimation->UpdateAttr();
1631 svg->PrepareAnimation(svgAnimation);
1632 EXPECT_EQ(svgAnimation->GetAttributeName(), "stroke-opacity");
1633
1634 svgAnimation->SetAttr("attributeName", "stroke-miterlimit");
1635 svgAnimation->UpdateAttr();
1636 svg->PrepareAnimation(svgAnimation);
1637 EXPECT_EQ(svgAnimation->GetAttributeName(), "stroke-miterlimit");
1638
1639 svgAnimation->SetAttr("attributeName", "stroke-dashoffset");
1640 svgAnimation->UpdateAttr();
1641 svg->PrepareAnimation(svgAnimation);
1642 EXPECT_EQ(svgAnimation->GetAttributeName(), "stroke-dashoffset");
1643
1644 svgAnimation->SetAttr("attributeName", "opacity");
1645 svgAnimation->UpdateAttr();
1646 svg->PrepareAnimation(svgAnimation);
1647
1648 // 150 = path
1649 int cnt = 150;
1650 svg->AsRSPath(Size(cnt, cnt));
1651 EXPECT_EQ(svgAnimation->GetAttributeName(), "opacity");
1652 }
1653
1654 /**
1655 * @tc.name: ParseLineTest002
1656 * @tc.desc: Create an SvgLine and set path
1657 * @tc.type: FUNC
1658 */
1659 HWTEST_F(ParseTestNg, ParseLineTest002, TestSize.Level1)
1660 {
1661 /* *
1662 * @tc.steps: step1. call AsPath
1663 * @tc.expected: Execute function return value not is nullptr
1664 */
1665 auto svgLine = AccessibilityManager::MakeRefPtr<SvgLine>();
1666 svgLine->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1667 EXPECT_NE(svgLine, nullptr);
1668 }
1669
1670 /**
1671 * @tc.name: ParseEllipseTest005
1672 * @tc.desc: Create an SvgEllipse and set path
1673 * @tc.type: FUNC
1674 */
1675 HWTEST_F(ParseTestNg, ParseEllipseTest005, TestSize.Level1)
1676 {
1677 auto svgStream = SkMemoryStream::MakeCopy(ELLIPSE_SVG_LABEL3.c_str(), ELLIPSE_SVG_LABEL3.length());
1678 EXPECT_NE(svgStream, nullptr);
1679
1680 /* *
1681 * @tc.steps: step1. call CreateSvgDom
1682 * @tc.expected: Execute function return value size not is 0
1683 */
1684 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
1685 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1686 EXPECT_GT(svg->children_.size(), 0);
1687
1688 /* *
1689 * @tc.steps: step2. call AsPath
1690 * @tc.expected: Execute function return value not is nullptr
1691 */
1692 auto svgEllipse = AceType::DynamicCast<SvgEllipse>(svg->children_.at(0));
1693 svgEllipse->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1694 EXPECT_NE(svgEllipse, nullptr);
1695 }
1696
1697 /**
1698 * @tc.name: ParseEllipseTest006
1699 * @tc.desc: Create an SvgEllipse and set patha
1700 * @tc.type: FUNC
1701 */
1702 HWTEST_F(ParseTestNg, ParseEllipseTest006, TestSize.Level1)
1703 {
1704 auto svgStream = SkMemoryStream::MakeCopy(ELLIPSE_SVG_LABEL4.c_str(), ELLIPSE_SVG_LABEL4.length());
1705 EXPECT_NE(svgStream, nullptr);
1706
1707 /* *
1708 * @tc.steps: step1. call CreateSvgDom
1709 * @tc.expected: Execute function return value size not is 0
1710 */
1711 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
1712 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1713 EXPECT_GT(svg->children_.size(), 0);
1714
1715 /* *
1716 * @tc.steps: step2. call AsPath
1717 * @tc.expected: Execute function return value not is nullptr
1718 */
1719 auto svgEllipse = AceType::DynamicCast<SvgEllipse>(svg->children_.at(0));
1720 svgEllipse->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1721 EXPECT_NE(svgEllipse, nullptr);
1722 }
1723
1724 /**
1725 * @tc.name: ParsePolygonTest003
1726 * @tc.desc: parse polygon and polyline label
1727 * @tc.type: FUNC
1728 */
1729 HWTEST_F(ParseTestNg, ParsePolygonTest003, TestSize.Level1)
1730 {
1731 /* *
1732 * @tc.steps: step1. call CreateSvgDom
1733 * @tc.expected: Execute svgDom root node is 2
1734 */
1735 auto svgStream = SkMemoryStream::MakeCopy(POLYGON_SVG_LABEL1.c_str(), POLYGON_SVG_LABEL1.length());
1736 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
1737 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1738 EXPECT_EQ(static_cast<int32_t>(svg->children_.size()), CHILD_NUMBER);
1739
1740 /* *
1741 * @tc.steps: step2. call UpdateGradient
1742 * @tc.expected: Execute SvgPolygon GradientType not is LINEAR
1743 */
1744 auto svgPolygon = AceType::DynamicCast<SvgPolygon>(svg->children_.at(0));
1745 Gradient temp;
1746 temp.SetType(GradientType::CONIC);
1747 svgPolygon->declaration_->SetGradient(temp);
1748 svgPolygon->UpdateGradient(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1749 EXPECT_NE(svgPolygon->fillState_.GetGradient()->GetType(), GradientType::LINEAR);
1750 }
1751
1752 /**
1753 * @tc.name: ParsePolygonTest004
1754 * @tc.desc: parse polygon and polyline label
1755 * @tc.type: FUNC
1756 */
1757 HWTEST_F(ParseTestNg, ParsePolygonTest004, TestSize.Level1)
1758 {
1759 /* *
1760 * @tc.steps: step1. call CreateSvgDom
1761 * @tc.expected: Execute svgDom root node is 2
1762 */
1763 auto svgStream = SkMemoryStream::MakeCopy(POLYGON_SVG_LABEL1.c_str(), POLYGON_SVG_LABEL1.length());
1764 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
1765 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1766 EXPECT_EQ(static_cast<int32_t>(svg->children_.size()), CHILD_NUMBER);
1767
1768 /* *
1769 * @tc.steps: step2. call AsPath
1770 * @tc.expected: Execute SvgPolygon Points is empty
1771 */
1772 auto svgPolygon = AceType::DynamicCast<SvgPolygon>(svg->children_.at(0));
1773 auto declaration = AceType::DynamicCast<SvgPolygonDeclaration>(svgPolygon->declaration_);
1774 declaration->SetPoints("");
1775 svgPolygon->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1776 EXPECT_TRUE(declaration->GetPoints().empty());
1777
1778 /* *
1779 * @tc.steps: step3. call AsPath
1780 * @tc.expected: Execute SvgPolygon Points parse error
1781 */
1782 declaration->SetPoints("ccc");
1783 svgPolygon->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1784 EXPECT_FALSE(declaration->GetPoints().empty());
1785 }
1786
1787 /**
1788 * @tc.name: ParseStyleTest002
1789 * @tc.desc: parse use label
1790 * @tc.type: FUNC
1791 */
1792 HWTEST_F(ParseTestNg, ParseStyleTest002, TestSize.Level1)
1793 {
1794 /* *
1795 * @tc.steps: step1. call ParseCssStyle
1796 * @tc.expected: Execute function return value false
1797 */
1798 SvgStyle::ParseCssStyle("", nullptr);
1799 std::string str;
__anon4092927c0302(const std::string& key, const std::pair<std::string, std::string>& value) 1800 PushAttr callback = [&str](const std::string& key, const std::pair<std::string, std::string>& value) { str = key; };
1801 SvgStyle::ParseCssStyle("body {font-style: oblique;}.normal {font-style: normal;}", callback);
1802 EXPECT_FALSE(str.empty());
1803
1804 SvgStyle::ParseCssStyle("body font-style: oblique;}. {font-style: normal;}", callback);
1805 EXPECT_FALSE(str.empty());
1806 }
1807
1808 /**
1809 * @tc.name: ParseRectTest004
1810 * @tc.desc: parse rect label
1811 * @tc.type: FUNC
1812 */
1813 HWTEST_F(ParseTestNg, ParseRectTest004, TestSize.Level1)
1814 {
1815 auto svgStream = SkMemoryStream::MakeCopy(RECT_SVG_LABEL3.c_str(), RECT_SVG_LABEL3.length());
1816 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::BLACK);
1817 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1818 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
1819
1820 /* *
1821 * @tc.steps: step1. call AsPath
1822 * @tc.expected: Execute function return value not is 0
1823 */
1824 auto svgRect = AceType::DynamicCast<SvgRect>(svg->children_.at(0));
1825 svgRect->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1826 auto rectDeclaration = AceType::DynamicCast<SvgRectDeclaration>(svgRect->declaration_);
1827 EXPECT_NE(rectDeclaration->GetRx().Value(), 0);
1828 }
1829
1830 /**
1831 * @tc.name: ParseUseTest002
1832 * @tc.desc: parse use label
1833 * @tc.type: FUNC
1834 */
1835 HWTEST_F(ParseTestNg, ParseUseTest002, TestSize.Level1)
1836 {
1837 auto svgStream = SkMemoryStream::MakeCopy(USE_SVG_LABEL.c_str(), USE_SVG_LABEL.length());
1838 auto svgDom = SvgDom::CreateSvgDom(*svgStream, Color::GREEN);
1839 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1840 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
1841
1842 /* *
1843 * @tc.steps: step1. call AsPath
1844 * @tc.expected: Execute function return value is true
1845 */
1846 auto svgUse = AceType::DynamicCast<SvgUse>(svg->children_.at(INDEX_ONE));
1847 svgUse->declaration_->SetHref("");
1848 svgUse->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1849 EXPECT_TRUE(svgUse->declaration_->GetHref().empty());
1850 }
1851 } // namespace OHOS::Ace::NG