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