1 /*
2 * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, 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/common/mock_container.h"
25 #include "test/mock/core/rosen/mock_canvas.h"
26
27 #include "base/memory/ace_type.h"
28 #include "core/components/common/layout/constants.h"
29 #include "core/components/common/properties/color.h"
30 #include "core/components/declaration/svg/svg_animate_declaration.h"
31 #include "core/components/declaration/svg/svg_circle_declaration.h"
32 #include "core/components/declaration/svg/svg_declaration.h"
33 #include "core/components/declaration/svg/svg_ellipse_declaration.h"
34 #include "core/components/declaration/svg/svg_fe_blend_declaration.h"
35 #include "core/components/declaration/svg/svg_fe_colormatrix_declaration.h"
36 #include "core/components/declaration/svg/svg_fe_composite_declaration.h"
37 #include "core/components/declaration/svg/svg_fe_declaration.h"
38 #include "core/components/declaration/svg/svg_fe_flood_declaration.h"
39 #include "core/components/declaration/svg/svg_fe_gaussianblur_declaration.h"
40 #include "core/components/declaration/svg/svg_filter_declaration.h"
41 #include "core/components/declaration/svg/svg_gradient_declaration.h"
42 #include "core/components/declaration/svg/svg_image_declaration.h"
43 #include "core/components/declaration/svg/svg_line_declaration.h"
44 #include "core/components/declaration/svg/svg_mask_declaration.h"
45 #include "core/components/declaration/svg/svg_path_declaration.h"
46 #include "core/components/declaration/svg/svg_pattern_declaration.h"
47 #include "core/components/declaration/svg/svg_polygon_declaration.h"
48 #include "core/components/declaration/svg/svg_rect_declaration.h"
49 #include "core/components/declaration/svg/svg_stop_declaration.h"
50 #include "core/components_ng/render/drawing.h"
51 #include "core/components_ng/svg/parse/svg_animation.h"
52 #include "core/components_ng/svg/parse/svg_circle.h"
53 #include "core/components_ng/svg/parse/svg_clip_path.h"
54 #include "core/components_ng/svg/parse/svg_defs.h"
55 #include "core/components_ng/svg/parse/svg_ellipse.h"
56 #include "core/components_ng/svg/parse/svg_fe_blend.h"
57 #include "core/components_ng/svg/parse/svg_fe_color_matrix.h"
58 #include "core/components_ng/svg/parse/svg_fe_composite.h"
59 #include "core/components_ng/svg/parse/svg_fe_flood.h"
60 #include "core/components_ng/svg/parse/svg_fe_gaussian_blur.h"
61 #include "core/components_ng/svg/parse/svg_fe_offset.h"
62 #include "core/components_ng/svg/parse/svg_filter.h"
63 #include "core/components_ng/svg/parse/svg_g.h"
64 #include "core/components_ng/svg/parse/svg_gradient.h"
65 #include "core/components_ng/svg/parse/svg_image.h"
66 #include "core/components_ng/svg/parse/svg_line.h"
67 #include "core/components_ng/svg/parse/svg_mask.h"
68 #include "core/components_ng/svg/parse/svg_path.h"
69 #include "core/components_ng/svg/parse/svg_pattern.h"
70 #include "core/components_ng/svg/parse/svg_polygon.h"
71 #include "core/components_ng/svg/parse/svg_rect.h"
72 #include "core/components_ng/svg/parse/svg_stop.h"
73 #include "core/components_ng/svg/parse/svg_style.h"
74 #include "core/components_ng/svg/parse/svg_svg.h"
75 #include "core/components_ng/svg/parse/svg_use.h"
76 #include "core/components_ng/svg/svg_dom.h"
77
78 using namespace testing;
79 using namespace testing::ext;
80 namespace OHOS::Ace::NG {
81 namespace {
82 const std::string CIRCLE_SVG_LABEL =
83 "<svg width=\"400px\" height=\"400px\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><circle cx=\"60px\" "
84 "cy=\"200px\" r = \"50px\" fill=\"red\" opacity=\"0.5\" stroke=\"blue\" stroke-width=\"16px\" "
85 "stroke-opacity=\"0.3\" id=\"circleId\"/></svg>";
86 const std::string CLIP_SVG_LABEL =
87 "<svg width=\"120\" height=\"120\" viewBox=\"0 0 120 120\" version=\"1.1\"><defs><clipPath id=\"myClip\"><circle "
88 "cx=\"30\" cy=\"30\" r=\"20\"/><circle cx=\"70\" cy=\"70\" r=\"30\"/></clipPath></defs><rect x=\"10\" y=\"10\" "
89 "width=\"100\" height=\"100\" clip-path=\"url(#myClip)\" fill=\"red\" /></svg>";
90 const std::string ID = "myClip";
91 const std::string SVG_LABEL = "<svg width=\"400\" height=\"500\" viewBox=\"-4 -10 300 300\"></svg>";
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 int32_t INDEX_ONE = 1;
117 const std::string STYLE_SVG_LABEL = "<svg viewBox=\"0 0 10 10\"><style>circle{fill:gold;stroke:maroon;stroke-width : "
118 "2px;}</style><circle cx =\"5\" cy=\"5\" r=\"4\" /></svg>";
119 const std::string STOP_SVG_LABEL =
120 "<svg height=\"150\" width=\"400\"><defs><linearGradient id=\"grad1\" x1=\"0%\" y1=\"0%\" x2=\"100%\" "
121 "y2=\"0%\"><stop offset=\"0%\" style=\"stop-color:rgb(255,255,0);stop-opacity:1\" /><stop offset=\"20px\" "
122 "style=\"stop-color:rgb(255,0,0);stop-opacity:1\" /></linearGradient></defs><ellipse cx=\"200\" cy=\"70\" "
123 "rx=\"85\" ry=\"55\" fill=\"url(#grad1)\" /></svg>";
124 constexpr int32_t CHILD_NUMBER = 2;
125 const std::string RECT_SVG_LABEL = "<svg width=\"400\" height=\"400\" version=\"1.1\" fill=\"red\" "
126 "xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"100\" height=\"100\" x=\"150\" "
127 "y=\"20\" stroke-width=\"4\" stroke=\"#000000\" rx=\"10\" ry=\"10\"></rect></svg>";
128 const std::string RECT_SVG_LABEL2 = "<svg version=\"1.1\" fill=\"red\" "
129 "xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"100\" height=\"100\" x=\"150\" "
130 "y=\"20\" stroke-width=\"4\" stroke=\"#000000\" rx=\"10\" ry=\"10\"></rect></svg>";
131 const std::string RECT_SVG_LABEL3 = "<svg version=\"1.1\" fill=\"red\" "
132 "xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"100\" height=\"100\" x=\"150\" "
133 "y=\"20\" stroke-width=\"4\" stroke=\"#000000\" rx=\"1\" ry=\"-1\"></rect></svg>";
134 const std::string RECT_SVG_LABEL4 = "<svg version=\"1.1\" fill=\"red\" "
135 "xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"100\" height=\"100\" x=\"150\" "
136 "y=\"20\" stroke-width=\"4\" stroke=\"#000000\" rx=\"-1\" ry=\"1\"></rect></svg>";
137 constexpr float X = 150.0f;
138 constexpr float Y = 20.0f;
139 constexpr float RX = 10.0f;
140 constexpr float RY = 10.0f;
141 constexpr float RECT_WIDTH = 100.0f;
142 constexpr float RECT_HEIGHT = 100.0f;
143 const std::string POLYGON_SVG_LABEL1 =
144 "<svg fill=\"white\" stroke=\"blue\" width=\"800\" height=\"400\" version=\"1.1\" "
145 "xmlns=\"http://www.w3.org/2000/svg\"><polygon points=\"10,110 60,35 60,85 110,10\" "
146 "fill=\"red\"></polygon> <polyline points=\"10,200 60,125 60,175 110,100\" "
147 "stroke-dasharray=\"10 5\" stroke-dashoffset=\"3\"></polyline></svg>";
148 const std::string POLYGON_SVG_LABEL2 =
149 "<svg fill=\"white\" stroke=\"blue\" width=\"300\" height=\"400\" version=\"1.1\" "
150 "xmlns=\"http://www.w3.org/2000/svg\"><polygon points=\"10,110 60,35 60,85 110,10\" "
151 "fill=\"red\"></polygon> <polyline points=\"10,200 60,125 60,175 110,100\" "
152 "stroke-dasharray=\"10 5\" stroke-dashoffset=\"3\"></polyline></svg>";
153 const std::string POLYGON_POINT = "10,110 60,35 60,85 110,10";
154 const std::string POLYLINE_POINT = "10,200 60,125 60,175 110,100";
155 const std::string PATTERN_SVG_LABEL =
156 "<svg viewBox=\"0 0 230 100\"><defs><pattern id=\"star\" viewBox=\"0 0 10 10\" width=\"10\" "
157 "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\" "
158 "cy=\"50\" r=\"50\" fill=\"url(#star)\" /><circle cx=\"180\" cy=\"50\" r=\"40\" fill=\"none\" stroke-width=\"20\" "
159 "stroke=\"url(#star)\"/> </svg>";
160 const std::string PATH_SVG_LABEL1 =
161 "<svg width=\"400\" height=\"800\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M 10,30 A 20,20 "
162 "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\" "
163 "fill=\"red\"></path></svg>";
164 const std::string PATH_SVG_LABEL2 =
165 "<svg version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M 10,30 A 20,20 "
166 "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\" "
167 "fill=\"red\"></path></svg>";
168 const std::string PATH_SVG_LABEL3 =
169 "<svg width=\"-400\" height=\"-400\" viewBox=\"-4 -10 300 300\" version=\"1.1\" "
170 "xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M 10,30 A 20,20 "
171 "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\" "
172 "fill=\"red\"></path></svg>";
173 const std::string PATH_SVG_LABEL4 =
174 "<svg width=\"300\" height=\"400\" viewBox=\"-4 -10 300 300\" version=\"1.1\" "
175 "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_LABEL5 =
179 "<svg width=\"400\" height=\"400\" viewBox=\"-4 -10 -300 -300\" version=\"1.1\" "
180 "xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M 10,30 A 20,20 "
181 "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\" "
182 "fill=\"red\"></path></svg>";
183 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";
184 const std::string MASK_SVG_LABEL =
185 "<svg width=\"50px\" height=\"50px\" viewBox=\"0 0 24 24\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" "
186 "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 "
187 "-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 "
188 "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 "
189 "-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\" "
190 "stroke-width=\"1\" fill=\"none\" fill-rule=\"evenodd\"><g><mask id=\"mask-2\" fill=\"#FFFFFF\"><use "
191 "xlink:href=\"#path-1\"></use></mask><use id=\"myId\" fill=\"#FFFFFF\" fill-rule=\"nonzero\" "
192 "xlink:href=\"#path-1\"></use></g></g></svg>";
193 const std::string MASK_ID = "mask-2";
194 const std::string LINE_SVG_LABEL =
195 "<svg width=\"400\" height=\"400\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><line x1=\"10\" x2=\"300\" "
196 "y1=\"50\" y2=\"50\" stroke-width=\"4\" fill=\"white\" stroke=\"blue\"></line></svg>";
197 const std::string GRADIENT_SVG_LINEAR =
198 "<svg height=\"150\" width=\"400\"><defs><linearGradient id=\"grad1\" x1=\"0%\" y1=\"0%\" x2=\"100%\" "
199 "y2=\"0%\"><stop offset=\"0%\" style=\"stop-color:rgb(255,255,0);stop-opacity:1\" /><stop offset=\"100%\" "
200 "style=\"stop-color:rgb(255,0,0);stop-opacity:1\" /></linearGradient></defs><ellipse cx=\"200\" cy=\"70\" "
201 "rx=\"85\" ry=\"55\" fill=\"url(#grad1)\" /></svg>";
202 const std::string GRADIENT_SVG_RADIAL =
203 "<svg height=\"150\" width=\"500\"><defs><radialGradient id=\"grad1\" cx=\"50%\" cy=\"50%\" r=\"50%\" fx=\"50%\" "
204 "fy=\"50%\"><stop offset=\"0%\" style=\"stop-color:rgb(255,255,255); stop-opacity:0\" /><stop offset=\"100%\" "
205 "style=\"stop-color:rgb(0,0,255);stop-opacity:1\" /></radialGradient></defs><ellipse cx=\"200\" cy=\"70\" "
206 "rx=\"85\" ry=\"55\" fill=\"url(#grad1)\" /></svg>";
207 const std::string G_SVG_LABEL = "<svg width=\"400\" height=\"500\"> <g id=\"myId\"> </g></svg>";
208 const std::string G_ID = "myId";
209 const std::string FILTER_SVG_LABEL =
210 "<svg height=\"900\" width=\"900\"><filter id=\"composite\" y=\"0\" x=\"0\" width=\"900\" "
211 "height=\"900\"><feTurbulence baseFrequency=\".05\" numOctaves=\"3\" result=\"B\"/><feComposite in2=\"B\" "
212 "in=\"SourceGraphic\" operator=\"in\" /></filter><ellipse cx=\"100\" cy=\"87\" rx=\"75\" ry=\"87\" fill=\"red\" "
213 "filter=\"url(#composite)\"/></svg>";
214 const std::string FILTER_ID = "composite";
215 const std::string FEGAUSS_SVG_LABEL =
216 "<svg width=\"230\" height=\"120\"><filter id=\"blurMe\"><feGaussianBlur in=\"Graphic\" stdDeviation=\"5\" "
217 "/></filter><circle cx=\"170\" cy=\"60\" r=\"50\" fill=\"green\" filter=\"url(#blurMe)\" /></svg>";
218 const std::string FEGAUSS_SVG_LABEL2 =
219 "<svg width=\"-230\" height=\"-120\"><filter id=\"blurMe\"><feGaussianBlur in=\"Graphic\" stdDeviation=\"5\" "
220 "/></filter><circle cx=\"170\" cy=\"60\" r=\"50\" fill=\"green\" filter=\"url(#blurMe)\" /></svg>";
221 const std::string COMPOSITE_SVG_LABEL =
222 "<svg height=\"900\" width=\"900\"><filter id=\"composite\" y=\"0\" x=\"0\" width=\"100%\" "
223 "height=\"100%\"><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 COLOR_MATRIX_SVG_LABEL =
227 "<svg height=\"900\" width=\"900\"><filter id=\"linear\"><feColorMatrix type=\"matrix\" "
228 "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\" "
229 "rx=\"75\" ry=\"87\" fill=\"red\" filter=\"url(#linear)\"></ellipse></svg>";
230 const std::string TYPE = "matrix";
231 const std::string VALUE = "R 0 0 0 0 0 G 0 0 0 0 0 B 0 0 0 0 0 A 0";
232 const std::string ELLIPSE_SVG_LABEL1 =
233 "<svg fill=\"white\" width=\"400\" height=\"400\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><ellipse "
234 "cx=\"60\" cy=\"200\" rx=\"50\" ry=\"100\" stroke-width=\"4\" fill=\"red\" stroke=\"blue\"></ellipse></svg>";
235 const std::string ELLIPSE_SVG_LABEL2 =
236 "<svg fill=\"white\" width=\"10\" height=\"10\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><ellipse "
237 "cx=\"60\" cy=\"200\" rx=\"50\" ry=\"100\" stroke-width=\"4\" fill=\"red\" stroke=\"blue\"></ellipse></svg>";
238 const std::string ELLIPSE_SVG_LABEL3 =
239 "<svg fill=\"white\" width=\"10\" height=\"10\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><ellipse "
240 "cx=\"0.0\" cy=\"0.0\" rx=\"-1\" ry=\"-1\" stroke-width=\"4\" fill=\"red\" stroke=\"blue\"></ellipse></svg>";
241 const std::string ELLIPSE_SVG_LABEL4 =
242 "<svg fill=\"white\" width=\"10\" height=\"10\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><ellipse "
243 "cx=\"0.0\" cy=\"0.0\" rx=\"1\" ry=\"-1\" stroke-width=\"4\" fill=\"red\" stroke=\"blue\"></ellipse></svg>";
244 constexpr float ELLIPSE_CX = 60.0f;
245 constexpr float ELLIPSE_CY = 200.0f;
246 constexpr float ELLIPSE_RX = 50.0f;
247 constexpr float ELLIPSE_RY = 100.0f;
248 const std::string SVG_ANIMATE_TRANSFORM(
249 "<svg width=\"200px\" height=\"200px\" viewBox=\"0 0 100 100\" xmlns=\"http://www.w3.org/2000/svg\">"
250 "<path d =\"M50 50L20 50A30 30 0 0 0 80 50Z\">"
251 "<animateTransform attributeName =\"transform\" type=\"rotate\" repeatCount=\"3\" dur=\"1s\""
252 " values=\"0 50 50;45 50 50;0 50 50\" keyTimes=\"0;0.5;1\"></animateTransform></path></svg>");
253
254 const std::string NONE_STR = "";
255 const std::string SATURATE_VALUE = "10";
256 const std::string HUE_ROTATE = "80";
257 const std::string FE_COLOR_MATRIX =
258 "<svg width=\"900\" height=\"900\" viewBox=\"0 0 150 120\" xmlns=\"http://www.w3.org/2000/svg\">"
259 "<filter id=\"colorMatrix\">"
260 "<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\" />"
261 "<feColorMatrix type=\"saturate\" values=\"10\"/>"
262 "<feColorMatrix type=\"hueRotate\" values=\"80\"/>"
263 "<feColorMatrix type=\"luminanceToAlpha\" values=\"80\"/>"
264 "<feColorMatrix type=\"matrix\" values=\"1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0\" />"
265 "</filter>"
266 "<g>"
267 "<circle cx=\"30\" cy=\"30\" r=\"20\" fill=\"red\" fill-opacity=\"0.5\" />"
268 "</g>"
269 "<g filter=\"url(#colorMatrix)\">"
270 "<circle cx=\"80\" cy=\"30\" r=\"20\" fill=\"red\" fill-opacity=\"0.5\" />"
271 "</g>"
272 "</svg>";
273
274 const std::string FE_GAUSSIAN_BLUR =
275 "<svg width=\"900\" height=\"900\" viewBox=\"0 0 150 120\" xmlns=\"http://www.w3.org/2000/svg\">"
276 "<filter id=\"colorMatrix\">"
277 "<feGaussianBlur stdDeviation=\"10 50\"/>"
278 "<feGaussianBlur stdDeviation=\"10\"/>"
279 "<feGaussianBlur stdDeviation=\"abc abc\"/>"
280 "</filter>"
281 "<g>"
282 "<rect width=\"90\" height=\"90\" fill=\"#0099cc\" filter=\"url(#blurFilter)\" />"
283 "</g>"
284 "</svg>";
285
286 const std::string FE_FLOOD_AND_COMPOSITE =
287 "<svg width=\"900\" height=\"900\" viewBox=\"0 0 150 120\" >"
288 "<filter id=\"colorMatrix\">"
289 "<feFlood flood-color=\"red\" flood-opacity=\"0\" result=\"flood\" /><feFlood flood-color=\"green\" "
290 "flood-opacity=\"1\" result=\"flood1\" />"
291 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"xor\" result=\"composite\" k1=\"1\" "
292 "k2=\"0\"/></filter>"
293 "<g><rect width=\"90\" height=\"90\" fill=\"#0099cc\" filter=\"url(#blurFilter)\" /></g></svg>";
294
295 const std::string FE_COMPOSITE =
296 "<svg width=\"900\" height=\"900\" viewBox=\"0 0 150 120\" >"
297 "<filter id=\"colorMatrix\">"
298 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"undefine\" result=\"composite\" k1=\"1\" "
299 "k2=\"0\"/>"
300 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"arithmetic\" result=\"composite\" k1=\"1\" "
301 "k2=\"0\"/>"
302 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"atop\" result=\"composite\" k1=\"1\" "
303 "k2=\"0\"/>"
304 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"in\" result=\"composite\" k1=\"1\" "
305 "k2=\"0\"/>"
306 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"lighter\" result=\"composite\" k1=\"1\" "
307 "k2=\"0\"/>"
308 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"out\" result=\"composite\" k1=\"1\" "
309 "k2=\"0\"/>"
310 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"xor\" result=\"composite\" k1=\"1\" "
311 "k2=\"0\"/>"
312 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"over\" result=\"composite\" k1=\"1\" "
313 "k2=\"0\"/></filter>"
314 "<g><rect width=\"90\" height=\"90\" fill=\"#0099cc\" filter=\"url(#blurFilter)\" /></g></svg>";
315
316 const std::string FE_BLEND =
317 "<svg width=\"900\" height=\"900\" viewBox=\"0 0 150 120\" xmlns=\"http://www.w3.org/2000/svg\">"
318 "<filter id=\"colorMatrix\">"
319 "<feBlend in=\"SourceGraphic\" in2=\"SourceAlpha\" mode=\"lighten\" />"
320 "</filter>"
321 "<g>"
322 "<rect width=\"90\" height=\"90\" fill=\"#0099cc\" filter=\"url(#blurFilter)\" />"
323 "</g>"
324 "</svg>";
325
326 const std::string IMAGE_HREF = "test.png";
327 const std::string IMAGE_LABEL =
328 "<svg width=\"900\" height=\"900\" viewBox=\"0 0 150 120\" xmlns=\"http://www.w3.org/2000/svg\">"
329 "<image id=\"image001\" x=\"150\" y=\"20\" width=\"100\" height=\"100\" href=\"test.png\" />"
330 "</svg>";
331
332 constexpr float IMAGE_COMPONENT_WIDTH = 100.0f;
333 constexpr float IMAGE_COMPONENT_HEIGHT = 100.0f;
334
335 std::unordered_map<std::string, std::shared_ptr<RSImageFilter>> resultHash;
336 } // namespace
337 class ParseTestTwoNg : public testing::Test {
338 public:
339 static RefPtr<SvgDom> ParseRect(const std::string& svgLabel);
340 RefPtr<SvgDom> parsePolygon(const std::string& svgLable);
341 static RefPtr<SvgDom> ParsePath(const std::string& svgLabel);
342 RefPtr<SvgDom> ParseFeGaussianblur(const std::string& svgLabel);
343 static RefPtr<SvgDom> ParseEllipse(const std::string& svgLabel);
344 void CallBack(Testing::MockCanvas& rSCanvas);
SetUpTestSuite()345 static void SetUpTestSuite()
346 {
347 MockContainer::SetUp();
348 }
TearDownTestSuite()349 static void TearDownTestSuite()
350 {
351 MockContainer::TearDown();
352 }
353 };
354
ParseRect(const std::string & svgLabel)355 RefPtr<SvgDom> ParseTestTwoNg::ParseRect(const std::string& svgLabel)
356 {
357 auto svgStream = SkMemoryStream::MakeCopy(RECT_SVG_LABEL.c_str(), RECT_SVG_LABEL.length());
358 EXPECT_NE(svgStream, nullptr);
359 ImageSourceInfo src;
360 src.SetFillColor(Color::BLACK);
361 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
362 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
363 EXPECT_NE(svg, nullptr);
364 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
365 auto svgRect = AceType::DynamicCast<SvgRect>(svg->children_.at(0));
366 EXPECT_NE(svgRect, nullptr);
367 auto rectDeclaration = svgRect->rectAttr_;
368 EXPECT_FLOAT_EQ(rectDeclaration.x.ConvertToPx(), X);
369 EXPECT_FLOAT_EQ(rectDeclaration.y.ConvertToPx(), Y);
370 EXPECT_FLOAT_EQ(rectDeclaration.rx.ConvertToPx(), RX);
371 EXPECT_FLOAT_EQ(rectDeclaration.ry.ConvertToPx(), RY);
372 EXPECT_FLOAT_EQ(rectDeclaration.width.ConvertToPx(), RECT_WIDTH);
373 EXPECT_FLOAT_EQ(rectDeclaration.height.ConvertToPx(), RECT_HEIGHT);
374 return svgDom;
375 }
376
parsePolygon(const std::string & svgLable)377 RefPtr<SvgDom> ParseTestTwoNg::parsePolygon(const std::string& svgLable)
378 {
379 auto svgStream = SkMemoryStream::MakeCopy(svgLable.c_str(), svgLable.length());
380 EXPECT_NE(svgStream, nullptr);
381 ImageSourceInfo src;
382 src.SetFillColor(Color::BLACK);
383 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
384 EXPECT_NE(svgDom, nullptr);
385 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
386 EXPECT_NE(svg, nullptr);
387 EXPECT_EQ(static_cast<int32_t>(svg->children_.size()), CHILD_NUMBER);
388 auto svgPolygon = AceType::DynamicCast<SvgPolygon>(svg->children_.at(0));
389 EXPECT_NE(svgPolygon, nullptr);
390 auto svgPolyline = AceType::DynamicCast<SvgPolygon>(svg->children_.at(1));
391 EXPECT_NE(svgPolyline, nullptr);
392 auto polygonDeclaration = svgPolygon->polyAttr_;
393 EXPECT_STREQ(polygonDeclaration.points.c_str(), POLYGON_POINT.c_str());
394 auto polylineDeclaration = svgPolyline->polyAttr_;
395 EXPECT_STREQ(polylineDeclaration.points.c_str(), POLYLINE_POINT.c_str());
396 return svgDom;
397 }
398
ParsePath(const std::string & svgLabel)399 RefPtr<SvgDom> ParseTestTwoNg::ParsePath(const std::string& svgLabel)
400 {
401 auto svgStream = SkMemoryStream::MakeCopy(svgLabel.c_str(), svgLabel.length());
402 EXPECT_NE(svgStream, nullptr);
403 ImageSourceInfo src;
404 src.SetFillColor(Color::BLACK);
405 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
406 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
407 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
408 auto svgPath = AceType::DynamicCast<SvgPath>(svg->children_.at(0));
409 EXPECT_NE(svgPath, nullptr);
410 auto pathDeclaration = svgPath->d_;
411 EXPECT_STREQ(pathDeclaration.c_str(), PATH_CMD.c_str());
412 return svgDom;
413 }
414
ParseFeGaussianblur(const std::string & svgLabel)415 RefPtr<SvgDom> ParseTestTwoNg::ParseFeGaussianblur(const std::string& svgLabel)
416 {
417 auto svgStream = SkMemoryStream::MakeCopy(svgLabel.c_str(), svgLabel.length());
418 EXPECT_NE(svgStream, nullptr);
419 ImageSourceInfo src;
420 src.SetFillColor(Color::BLACK);
421 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
422 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
423 EXPECT_GT(svg->children_.size(), 0);
424 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
425 EXPECT_NE(svgFilter, nullptr);
426 auto svgFeGaussiaBlur = AceType::DynamicCast<SvgFeGaussianBlur>(svgFilter->children_.at(0));
427 EXPECT_NE(svgFeGaussiaBlur, nullptr);
428 auto feDeclaration = svgFeGaussiaBlur->gaussianBlurAttr_;
429 EXPECT_EQ(feDeclaration.edgeMode, SvgFeEdgeMode::EDGE_DUPLICATE);
430 return svgDom;
431 }
432
ParseEllipse(const std::string & svgLabel)433 RefPtr<SvgDom> ParseTestTwoNg::ParseEllipse(const std::string& svgLabel)
434 {
435 auto svgStream = SkMemoryStream::MakeCopy(svgLabel.c_str(), svgLabel.length());
436 EXPECT_NE(svgStream, nullptr);
437 ImageSourceInfo src;
438 src.SetFillColor(Color::BLACK);
439 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
440 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
441 EXPECT_GT(svg->children_.size(), 0);
442 auto svgEllipse = AceType::DynamicCast<SvgEllipse>(svg->children_.at(0));
443 EXPECT_NE(svgEllipse, nullptr);
444 auto ellipseDeclaration = svgEllipse->ellipseAttr_;
445 EXPECT_FLOAT_EQ(ellipseDeclaration.cx.ConvertToPx(), ELLIPSE_CX);
446 EXPECT_FLOAT_EQ(ellipseDeclaration.cy.ConvertToPx(), ELLIPSE_CY);
447 EXPECT_FLOAT_EQ(ellipseDeclaration.rx.ConvertToPx(), ELLIPSE_RX);
448 EXPECT_FLOAT_EQ(ellipseDeclaration.ry.ConvertToPx(), ELLIPSE_RY);
449 return svgDom;
450 }
451
CallBack(Testing::MockCanvas & rSCanvas)452 void ParseTestTwoNg::CallBack(Testing::MockCanvas& rSCanvas)
453 {
454 EXPECT_CALL(rSCanvas, AttachBrush(_)).WillRepeatedly(ReturnRef(rSCanvas));
455 EXPECT_CALL(rSCanvas, DetachBrush()).WillRepeatedly(ReturnRef(rSCanvas));
456 EXPECT_CALL(rSCanvas, AttachPen(_)).WillRepeatedly(ReturnRef(rSCanvas));
457 EXPECT_CALL(rSCanvas, DetachPen()).WillRepeatedly(ReturnRef(rSCanvas));
458 EXPECT_CALL(rSCanvas, DrawPath(_)).Times(AtLeast(1));
459 }
460
461 /**
462 * @tc.name: ParseLineTest002
463 * @tc.desc: Create an SvgLine and set path
464 * @tc.type: FUNC
465 */
466 HWTEST_F(ParseTestTwoNg, ParseLineTest002, TestSize.Level1)
467 {
468 /* *
469 * @tc.steps: step1. call AsPath
470 * @tc.expected: Execute function return value not is nullptr
471 */
472 auto svgLine = AccessibilityManager::MakeRefPtr<SvgLine>();
473 svgLine->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
474 EXPECT_NE(svgLine, nullptr);
475 }
476
477 /**
478 * @tc.name: ParseEllipseTest005
479 * @tc.desc: Create an SvgEllipse and set path
480 * @tc.type: FUNC
481 */
482 HWTEST_F(ParseTestTwoNg, ParseEllipseTest005, TestSize.Level1)
483 {
484 auto svgStream = SkMemoryStream::MakeCopy(ELLIPSE_SVG_LABEL3.c_str(), ELLIPSE_SVG_LABEL3.length());
485 EXPECT_NE(svgStream, nullptr);
486
487 /* *
488 * @tc.steps: step1. call CreateSvgDom
489 * @tc.expected: Execute function return value size not is 0
490 */
491 ImageSourceInfo src;
492 src.SetFillColor(Color::BLACK);
493 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
494 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
495 EXPECT_GT(svg->children_.size(), 0);
496
497 /* *
498 * @tc.steps: step2. call AsPath
499 * @tc.expected: Execute function return value not is nullptr
500 */
501 auto svgEllipse = AceType::DynamicCast<SvgEllipse>(svg->children_.at(0));
502 svgEllipse->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
503 EXPECT_NE(svgEllipse, nullptr);
504 }
505
506 /**
507 * @tc.name: ParseEllipseTest006
508 * @tc.desc: Create an SvgEllipse and set patha
509 * @tc.type: FUNC
510 */
511 HWTEST_F(ParseTestTwoNg, ParseEllipseTest006, TestSize.Level1)
512 {
513 auto svgStream = SkMemoryStream::MakeCopy(ELLIPSE_SVG_LABEL4.c_str(), ELLIPSE_SVG_LABEL4.length());
514 EXPECT_NE(svgStream, nullptr);
515
516 /* *
517 * @tc.steps: step1. call CreateSvgDom
518 * @tc.expected: Execute function return value size not is 0
519 */
520 ImageSourceInfo src;
521 src.SetFillColor(Color::BLACK);
522 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
523 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
524 EXPECT_GT(svg->children_.size(), 0);
525
526 /* *
527 * @tc.steps: step2. call AsPath
528 * @tc.expected: Execute function return value not is nullptr
529 */
530 auto svgEllipse = AceType::DynamicCast<SvgEllipse>(svg->children_.at(0));
531 svgEllipse->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
532 EXPECT_NE(svgEllipse, nullptr);
533 }
534
535 /**
536 * @tc.name: ParsePolygonTest003
537 * @tc.desc: parse polygon and polyline label
538 * @tc.type: FUNC
539 */
540 HWTEST_F(ParseTestTwoNg, ParsePolygonTest003, TestSize.Level1)
541 {
542 /* *
543 * @tc.steps: step1. call CreateSvgDom
544 * @tc.expected: Execute svgDom root node is 2
545 */
546 auto svgStream = SkMemoryStream::MakeCopy(POLYGON_SVG_LABEL1.c_str(), POLYGON_SVG_LABEL1.length());
547 ImageSourceInfo src;
548 src.SetFillColor(Color::BLACK);
549 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
550 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
551 EXPECT_EQ(static_cast<int32_t>(svg->children_.size()), CHILD_NUMBER);
552
553 /* *
554 * @tc.steps: step2. call AsPath
555 * @tc.expected: Execute SvgPolygon Points is empty
556 */
557 auto svgPolygon = AceType::DynamicCast<SvgPolygon>(svg->children_.at(0));
558 auto declaration = svgPolygon->polyAttr_;
559 declaration.points = "";
560 svgPolygon->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
561 EXPECT_TRUE(declaration.points.empty());
562
563 /* *
564 * @tc.steps: step3. call AsPath
565 * @tc.expected: Execute SvgPolygon Points parse error
566 */
567 declaration.points = "ccc";
568 svgPolygon->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
569 EXPECT_FALSE(declaration.points.empty());
570 }
571
572 /**
573 * @tc.name: ParseStyleTest002
574 * @tc.desc: parse use label
575 * @tc.type: FUNC
576 */
577 HWTEST_F(ParseTestTwoNg, ParseStyleTest002, TestSize.Level1)
578 {
579 /* *
580 * @tc.steps: step1. call ParseCssStyle
581 * @tc.expected: Execute function return value false
582 */
583 SvgStyle::ParseCssStyle("", nullptr);
584 std::string str;
__anonf52872f50202(const std::string& key, const std::pair<std::string, std::string>& value) 585 PushAttr callback = [&str](const std::string& key, const std::pair<std::string, std::string>& value) { str = key; };
586 SvgStyle::ParseCssStyle("body {font-style: oblique;}.normal {font-style: normal;}", callback);
587 EXPECT_FALSE(str.empty());
588
589 SvgStyle::ParseCssStyle("body font-style: oblique;}. {font-style: normal;}", callback);
590 EXPECT_FALSE(str.empty());
591 }
592
593 /**
594 * @tc.name: ParseRectTest004
595 * @tc.desc: parse rect label
596 * @tc.type: FUNC
597 */
598 HWTEST_F(ParseTestTwoNg, ParseRectTest004, TestSize.Level1)
599 {
600 auto svgStream = SkMemoryStream::MakeCopy(RECT_SVG_LABEL3.c_str(), RECT_SVG_LABEL3.length());
601 ImageSourceInfo src;
602 src.SetFillColor(Color::BLACK);
603 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
604 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
605 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
606
607 /* *
608 * @tc.steps: step1. call AsPath
609 * @tc.expected: Execute function return value not is 0
610 */
611 auto svgRect = AceType::DynamicCast<SvgRect>(svg->children_.at(0));
612 svgRect->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
613 auto rectDeclaration = svgRect->rectAttr_;
614 EXPECT_NE(rectDeclaration.rx.Value(), 0);
615 }
616
617 /**
618 * @tc.name: ParseUseTest002
619 * @tc.desc: parse use label
620 * @tc.type: FUNC
621 */
622 HWTEST_F(ParseTestTwoNg, ParseUseTest002, TestSize.Level1)
623 {
624 auto svgStream = SkMemoryStream::MakeCopy(USE_SVG_LABEL.c_str(), USE_SVG_LABEL.length());
625 ImageSourceInfo src;
626 src.SetFillColor(Color::GREEN);
627 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
628 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
629 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
630
631 /* *
632 * @tc.steps: step1. call AsPath
633 * @tc.expected: Execute function return value is true
634 */
635 auto svgUse = AceType::DynamicCast<SvgUse>(svg->children_.at(INDEX_ONE));
636 svgUse->attributes_.href = "";
637 svgUse->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
638 EXPECT_TRUE(svgUse->attributes_.href.empty());
639 }
640
641 /**
642 * @tc.name: ParseImageTest001
643 * @tc.desc: parse image label
644 * @tc.type: FUNC
645 */
646 HWTEST_F(ParseTestTwoNg, ParseImageTest001, TestSize.Level1)
647 {
648 auto svgStream = SkMemoryStream::MakeCopy(IMAGE_LABEL.c_str(), IMAGE_LABEL.length());
649 ImageSourceInfo src;
650 src.SetFillColor(Color::BLACK);
651 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
652 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
653 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
654
655 /* *
656 * @tc.steps: step1. call AsPath
657 * @tc.expected: Execute function return value is true
658 */
659 auto svgImage = AceType::DynamicCast<SvgImage>(svg->children_.at(0));
660 auto imageDeclaration = svgImage->imageAttr_;
661 EXPECT_FLOAT_EQ(imageDeclaration.x.ConvertToPx(), X);
662 EXPECT_FLOAT_EQ(imageDeclaration.y.ConvertToPx(), Y);
663 EXPECT_FLOAT_EQ(imageDeclaration.width.ConvertToPx(), RECT_WIDTH);
664 EXPECT_FLOAT_EQ(imageDeclaration.height.ConvertToPx(), RECT_HEIGHT);
665 EXPECT_STREQ(imageDeclaration.href.c_str(), IMAGE_HREF.c_str());
666 }
667
668 /**
669 * @tc.name: ParseGradientTest001
670 * @tc.desc: parse Gradient set
671 * @tc.type: FUNC
672 */
673 HWTEST_F(ParseTestTwoNg, ParseGradientTest001, TestSize.Level1)
674 {
675 auto svgStream = SkMemoryStream::MakeCopy(CIRCLE_SVG_LABEL.c_str(), CIRCLE_SVG_LABEL.length());
676 EXPECT_NE(svgStream, nullptr);
677 ImageSourceInfo src;
678 src.SetFillColor(Color::BLACK);
679 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
680 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
681 EXPECT_GT(svg->children_.size(), 0);
682 auto svgCircle = AceType::DynamicCast<SvgCircle>(svg->children_.at(0));
683 EXPECT_NE(svgCircle, nullptr);
684
685 OHOS::Ace::Gradient gradient;
686 OHOS::Ace::LinearGradient linearGradientLocal;
687 linearGradientLocal.x1 = Dimension(1.0);
688 linearGradientLocal.x2 = Dimension(1.0);
689 linearGradientLocal.y1 = Dimension(1.0);
690 linearGradientLocal.y2 = Dimension(1.0);
691 gradient.SetLinearGradient(linearGradientLocal);
692 svgCircle->SetLinearGradient(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), gradient);
693 auto linearGradientInfo = gradient.GetLinearGradientInfo();
694 EXPECT_NE(linearGradientInfo.x1, 0.0);
695 linearGradientLocal.x1 = Dimension(1.0, DimensionUnit::PERCENT);
696 linearGradientLocal.x2 = Dimension(1.0, DimensionUnit::PERCENT);
697 linearGradientLocal.y1 = Dimension(1.0, DimensionUnit::PERCENT);
698 linearGradientLocal.y2 = Dimension(1.0, DimensionUnit::PERCENT);
699 gradient.SetLinearGradient(linearGradientLocal);
700 svgCircle->SetLinearGradient(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), gradient);
701 linearGradientInfo = gradient.GetLinearGradientInfo();
702 EXPECT_EQ(linearGradientInfo.x1, 0.0);
703
704 OHOS::Ace::RadialGradient radialGradientLocal;
705 radialGradientLocal.radialHorizontalSize = AnimatableDimension(1);
706 radialGradientLocal.radialCenterX = AnimatableDimension(1);
707 radialGradientLocal.radialCenterY = AnimatableDimension(1);
708 radialGradientLocal.fRadialCenterX = Dimension(1);
709 radialGradientLocal.fRadialCenterY = Dimension(1);
710 gradient.SetRadialGradient(radialGradientLocal);
711 auto radialGradientInfo = gradient.GetRadialGradientInfo();
712 EXPECT_EQ(radialGradientInfo.r, 0.0);
713 EXPECT_EQ(radialGradientInfo.cx, 0.0);
714 EXPECT_EQ(radialGradientInfo.cy, 0.0);
715 EXPECT_EQ(radialGradientInfo.fx, 0.0);
716 EXPECT_EQ(radialGradientInfo.fy, 0.0);
717 svgCircle->SetRadialGradient(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), gradient);
718 radialGradientInfo = gradient.GetRadialGradientInfo();
719 EXPECT_NE(radialGradientInfo.r, 0.0);
720 EXPECT_NE(radialGradientInfo.cx, 0.0);
721 EXPECT_NE(radialGradientInfo.cy, 0.0);
722 EXPECT_NE(radialGradientInfo.fx, 0.0);
723 EXPECT_NE(radialGradientInfo.fy, 0.0);
724 }
725
726 /**
727 * @tc.name: ParseGradientTest002
728 * @tc.desc: parse Gradient set
729 * @tc.type: FUNC
730 */
731 HWTEST_F(ParseTestTwoNg, ParseGradientTest002, TestSize.Level1)
732 {
__anonf52872f50302(const OHOS::Ace::Gradient& gradient) 733 std::function func = [&](const OHOS::Ace::Gradient& gradient) {
734 auto svgStream = SkMemoryStream::MakeCopy(CIRCLE_SVG_LABEL.c_str(), CIRCLE_SVG_LABEL.length());
735 EXPECT_NE(svgStream, nullptr);
736 ImageSourceInfo src;
737 src.SetFillColor(Color::BLACK);
738 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
739 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
740 auto svgCircle = AceType::DynamicCast<SvgCircle>(svg->children_.at(0));
741 EXPECT_NE(svgCircle, nullptr);
742
743 auto viewPort = Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT);
744 auto baseAttr = svgCircle->GetBaseAttributes();
745 svgCircle->fillState_.SetGradient(gradient);
746 baseAttr.fillState.SetGradient(gradient);
747 baseAttr.strokeState.SetGradient(gradient);
748 svgCircle->SetBaseAttributes(baseAttr);
749 svgCircle->SetGradientStyle(0);
750 svgCircle->SetStrokeGradientStyle(0);
751 svgCircle->UpdateFillGradient(viewPort);
752 svgCircle->UpdateStrokeGradient(viewPort);
753
754 OHOS::Ace::RadialGradient radialGradientLocal;
755 radialGradientLocal.radialHorizontalSize = AnimatableDimension(1);
756 radialGradientLocal.radialCenterX = AnimatableDimension(1);
757 radialGradientLocal.radialCenterY = AnimatableDimension(1);
758 radialGradientLocal.fRadialCenterX = Dimension(1);
759 radialGradientLocal.fRadialCenterY = Dimension(1);
760 svgCircle->fillState_.SetGradient(gradient);
761 baseAttr.fillState.SetGradient(gradient);
762 baseAttr.strokeState.SetGradient(gradient);
763 svgCircle->SetBaseAttributes(baseAttr);
764 svgCircle->SetGradientStyle(1);
765 svgCircle->SetStrokeGradientStyle(1);
766 svgCircle->UpdateFillGradient(viewPort);
767 svgCircle->UpdateStrokeGradient(viewPort);
768 };
769 OHOS::Ace::Gradient gradient;
770 func(gradient);
771 gradient.AddColor(OHOS::Ace::GradientColor(Color::RED));
772 func(gradient);
773 }
774
775 /**
776 * @tc.name: ParseNodeTest001
777 * @tc.desc: SvgNode SetAttr Parameters
778 * @tc.type: FUNC
779 */
780 HWTEST_F(ParseTestTwoNg, ParseNodeTest001, TestSize.Level1)
781 {
782 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
783 svgNode->SetAttr("stroke-dasharray", "");
784
785 svgNode->SetAttr("stroke-linecap", "round");
786 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineCap(), LineCapStyle::ROUND);
787
788 svgNode->SetAttr("strokeLinecap", "square");
789 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineCap(), LineCapStyle::SQUARE);
790
791 svgNode->SetAttr("stroke-linejoin", "bevel");
792 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineJoin(), LineJoinStyle::BEVEL);
793
794 svgNode->SetAttr("strokeLinejoin", "round");
795 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineJoin(), LineJoinStyle::ROUND);
796
797 svgNode->SetAttr("stroke-miterlimit", "0.1");
798 EXPECT_NE(svgNode->GetBaseAttributes().strokeState.GetMiterLimit(), 0.1);
799
800 svgNode->SetAttr("stroke-miterlimit", "1.1");
801 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetMiterLimit(), 1.1);
802
803 svgNode->SetAttr("strokeMiterlimit", "0.2");
804 EXPECT_NE(svgNode->GetBaseAttributes().strokeState.GetMiterLimit(), 0.2);
805
806 svgNode->SetAttr("strokeMiterlimit", "1.2");
807 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetMiterLimit(), 1.2);
808
809 svgNode->SetAttr("strokeOpacity", "0.321");
810 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetOpacity().GetValue(), 0.321);
811
812 svgNode->SetAttr("strokeWidth", "1.2");
813 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineWidth().Value(), 1.2);
814
815 svgNode->SetAttr("strokeWidth", "-1.2");
816 EXPECT_NE(svgNode->GetBaseAttributes().strokeState.GetLineWidth().Value(), -1.2);
817
818 svgNode->SetAttr("stroke-width", "-1.2");
819 EXPECT_NE(svgNode->GetBaseAttributes().strokeState.GetLineWidth().Value(), -1.2);
820
821 svgNode->SetAttr("strokeDasharray", "");
822 svgNode->SetAttr("strokeDasharray", "1.1 1.2");
823 auto tesData = std::vector { 1.1, 1.2 };
824 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineDash().lineDash, tesData);
825
826 svgNode->SetAttr("strokeDashoffset", "2.0");
827 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineDash().dashOffset, 2.0);
828
829 svgNode->SetAttr("transform-origin", "10 10");
830 EXPECT_EQ(Dimension(10), svgNode->GetBaseAttributes().transformOrigin.first);
831 EXPECT_EQ(Dimension(10), svgNode->GetBaseAttributes().transformOrigin.second);
832
833 svgNode->SetAttr("xlink:href", "test_xlink:href");
834 EXPECT_NE(svgNode->GetBaseAttributes().href, "test_xlink:href");
835 }
836
837 /**
838 * @tc.name: ParseNodeTest002
839 * @tc.desc: SvgNode test
840 * @tc.type: FUNC
841 */
842 HWTEST_F(ParseTestTwoNg, ParseNodeTest002, TestSize.Level1)
843 {
844 auto svgStream = SkMemoryStream::MakeCopy(SVG_ANIMATE_TRANSFORM.c_str(), SVG_ANIMATE_TRANSFORM.length());
845 ImageSourceInfo src;
846 Size size;
847 src.SetFillColor(Color::GREEN);
848 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
849 EXPECT_NE(svgDom, nullptr);
850 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
851 EXPECT_NE(svg, nullptr);
852
853 Testing::MockCanvas rSCanvas;
854 CallBack(rSCanvas);
855 svg->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
856 svg->OnFilter(rSCanvas, size);
857 auto containerSize = svgDom->GetContainerSize();
858 EXPECT_EQ(containerSize, SizeF(200.0f, 200.0f));
859 svgDom->SetFillColor(Color::RED);
860 EXPECT_EQ(svgDom->fillColor_.value(), Color::RED);
861 svgDom->ControlAnimation(true);
862 svgDom->SetSmoothEdge(1.1f);
863 EXPECT_EQ(svgDom->smoothEdge_, 1.1f);
864 }
865
866 /**
867 * @tc.name: ParseNodeTest003
868 * @tc.desc: SvgNode test
869 * @tc.type: FUNC
870 */
871 HWTEST_F(ParseTestTwoNg, ParseNodeTest003, TestSize.Level1)
872 {
873 Size size;
874 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
875 auto dimension = Dimension(0.0, DimensionUnit::PERCENT);
876
877 SvgLengthType svgLengthType = static_cast<SvgLengthType>(int(SvgLengthType::OTHER) + 1);
878 EXPECT_EQ(svgNode->ConvertDimensionToPx(dimension, size, svgLengthType), 0.0);
879 dimension.SetUnit(DimensionUnit::AUTO);
880 EXPECT_EQ(svgNode->ConvertDimensionToPx(dimension, size, svgLengthType), 0.0);
881
882 EXPECT_EQ(svgNode->ConvertDimensionToPx(dimension, 1.0), 0.0);
883
884 EXPECT_EQ(svgNode->GetRootViewBox(), Rect());
885 }
886
887 /**
888 * @tc.name: ParseNodeTest004
889 * @tc.desc: SvgNode test
890 * @tc.type: FUNC
891 */
892 HWTEST_F(ParseTestTwoNg, ParseNodeTest004, TestSize.Level1)
893 {
894 auto svgStream = SkMemoryStream::MakeCopy(SVG_ANIMATE_TRANSFORM.c_str(), SVG_ANIMATE_TRANSFORM.length());
895 ImageSourceInfo src;
896 Size size = { 100, 100 };
897 src.SetFillColor(Color::GREEN);
898 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
__anonf52872f50402()899 svgDom->SetAnimationOnFinishCallback([](){});
900 svgDom->SetColorFilter(std::nullopt);
901 Testing::MockCanvas rSCanvas;
902 CallBack(rSCanvas);
903 svgDom->DrawImage(rSCanvas, ImageFit::SCALE_DOWN, size);
904 }
905
906 /**
907 * @tc.name: ParseNodeTest005
908 * @tc.desc: SvgNode SetAttr Parameters
909 * @tc.type: FUNC
910 */
911 HWTEST_F(ParseTestTwoNg, ParseNodeTest005, TestSize.Level1)
912 {
913 /* *
914 * @tc.steps: step1. create svg node
915 */
916 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
917
918 /* *
919 * @tc.steps: step2. set strokeLinecap
920 * @tc.expected: The property is set successfully
921 */
922 svgNode->SetAttr("strokeLinecap", "butt");
923 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineCap(), LineCapStyle::BUTT);
924
925 /* *
926 * @tc.steps: step3. set strokeLinejoin
927 * @tc.expected: The property is set successfully
928 */
929 svgNode->SetAttr("strokeLinejoin", "miter");
930 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineJoin(), LineJoinStyle::MITER);
931
932 /* *
933 * @tc.steps: step4. set fill
934 * @tc.expected: The property is set successfully
935 */
936 int32_t settingApiVersion = static_cast<int32_t>(PlatformVersion::VERSION_EIGHTEEN);
937 int32_t backupApiVersion = MockContainer::Current()->GetApiTargetVersion();
938 MockContainer::Current()->SetApiTargetVersion(settingApiVersion);
939
940 svgNode->SetAttr("fill", "#003153");
941 EXPECT_EQ(svgNode->GetBaseAttributes().fillState.GetColor().GetValue(), 0xFF003153);
942 MockContainer::Current()->SetApiTargetVersion(backupApiVersion);
943 }
944
945 /**
946 * @tc.name: ParseAnimation001
947 * @tc.desc: Test SvgAnimation SetAttr Method.
948 * @tc.type: FUNC
949 */
950 HWTEST_F(ParseTestTwoNg, ParseAnimation001, TestSize.Level1)
951 {
952 auto svgAnimation = AccessibilityManager::MakeRefPtr<SvgAnimation>(SvgAnimateType::MOTION);
953 EXPECT_NE(svgAnimation, nullptr);
954
955 svgAnimation->SetAttr("begin", "1000ms");
956 svgAnimation->UpdateAttr();
957 EXPECT_EQ(svgAnimation->GetBegin(), 1000);
958
959 svgAnimation->SetAttr("dur", "indefinite");
960 svgAnimation->UpdateAttr();
961 EXPECT_EQ(svgAnimation->GetDur(), 0);
962
963 svgAnimation->SetAttr("repeatcount", "indefinite");
964 svgAnimation->UpdateAttr();
965 EXPECT_EQ(svgAnimation->GetRepeatCount(), -1);
966
967 svgAnimation->SetAttr("keytimes", "");
968 svgAnimation->UpdateAttr();
969 EXPECT_EQ(svgAnimation->GetKeyTimes().size(), 0);
970
971 svgAnimation->SetAttr("keysplines", "");
972 svgAnimation->UpdateAttr();
973 EXPECT_EQ(svgAnimation->GetKeySplines().size(), 0);
974
975 svgAnimation->SetAttr("keysplines", "0.25;0.1;0.25;1");
976 svgAnimation->UpdateAttr();
977 EXPECT_EQ(svgAnimation->GetKeySplines().size(), 4);
978
979 svgAnimation->SetAttr("keypoints", "");
980 svgAnimation->UpdateAttr();
981 EXPECT_EQ(svgAnimation->GetKeyPoints().size(), 0);
982
983 svgAnimation->SetAttr("keypoints", "0;0.4;1");
984 svgAnimation->UpdateAttr();
985 EXPECT_EQ(svgAnimation->GetKeyPoints().size(), 3);
986 }
987
988 /**
989 * @tc.name: ParseAnimation002
990 * @tc.desc: Test SvgAnimation CreatePropertyAnimation Method.
991 * @tc.type: FUNC
992 */
993 HWTEST_F(ParseTestTwoNg, ParseAnimation002, TestSize.Level1)
994 {
995 auto svgAnimation = AccessibilityManager::MakeRefPtr<SvgAnimation>(SvgAnimateType::TRANSFORM);
996 EXPECT_NE(svgAnimation, nullptr);
997
998 svgAnimation->SetAttr("begin", "1000ms");
999 svgAnimation->UpdateAttr();
1000 EXPECT_EQ(svgAnimation->GetBegin(), 1000);
1001
__anonf52872f50502(double x) 1002 std::function<void(double)> callback = [](double x) -> void { x = 0; };
1003 const double value = 0;
1004 svgAnimation->values_ = { "1" };
1005 svgAnimation->CreatePropertyAnimation<double>(value, std::move(callback));
1006 EXPECT_NE(svgAnimation->animator_, nullptr);
1007 svgAnimation->animator_->Finish();
1008 EXPECT_EQ(svgAnimation->animator_->IsStopped(), true);
1009
1010 svgAnimation->CreatePropertyAnimation<double>(value, std::move(callback));
1011 EXPECT_EQ(svgAnimation->animator_->IsStopped(), false);
1012 }
1013
1014 /**
1015 * @tc.name: ParseAnimation003
1016 * @tc.desc: Create Animation SetAttr
1017 * @tc.type: FUNC
1018 */
1019 HWTEST_F(ParseTestTwoNg, ParseAnimation003, TestSize.Level1)
1020 {
1021 auto svgAnimation = AccessibilityManager::MakeRefPtr<SvgAnimation>(SvgAnimateType::MOTION);
1022 EXPECT_NE(svgAnimation, nullptr);
1023
1024 /* *
1025 * @tc.steps: step1. call SetAttr
1026 * @tc.expected: Attribute set successfully
1027 */
1028 svgAnimation->SetAttr("attributeName", "fill");
1029 svgAnimation->UpdateAttr();
1030 auto svg = SvgSvg::Create();
1031 EXPECT_NE(svg, nullptr);
1032 svg->PrepareAnimation(svgAnimation);
1033 EXPECT_EQ(svgAnimation->GetAttributeName(), "fill");
1034
1035 svgAnimation->SetAttr("calcmode", "paced");
1036 svgAnimation->UpdateAttr();
1037 EXPECT_EQ(svgAnimation->GetCalcMode(), CalcMode::PACED);
1038
1039 svgAnimation->SetAttr("from", "blue");
1040 svgAnimation->UpdateAttr();
1041 EXPECT_EQ(svgAnimation->GetFrom(), "blue");
1042
1043 svgAnimation->SetAttr("to", "red");
1044 svgAnimation->UpdateAttr();
1045 EXPECT_EQ(svgAnimation->GetTo(), "red");
1046
1047 svgAnimation->SetAttr("path", "M0 0 L100 100");
1048 svgAnimation->UpdateAttr();
1049 EXPECT_EQ(svgAnimation->GetPath(), "M0 0 L100 100");
1050
1051 svgAnimation->SetAttr("rotate", "45");
1052 svgAnimation->UpdateAttr();
1053 EXPECT_EQ(svgAnimation->GetRotate(), "45");
1054 }
1055
1056 /**
1057 * @tc.name: ParseStopTest001
1058 * @tc.desc: parse stop label
1059 * @tc.type: FUNC
1060 */
1061 HWTEST_F(ParseTestTwoNg, ParseStopTest001, TestSize.Level1)
1062 {
1063 int32_t settingApiVersion = static_cast<int32_t>(PlatformVersion::VERSION_EIGHTEEN);
1064 int32_t backupApiVersion = MockContainer::Current()->GetApiTargetVersion();
1065 MockContainer::Current()->SetApiTargetVersion(settingApiVersion);
1066
1067 /* *
1068 * @tc.steps: step1. create svgStop node
1069 */
1070 auto svgNode = SvgStop::Create();
1071 auto svgStop = AceType::DynamicCast<SvgStop>(svgNode);
1072 EXPECT_EQ(svgStop->stopAttr_.gradientColor.GetColor(), Color::BLACK);
1073
1074 /* *
1075 * @tc.steps: step2. parse stop-color
1076 * @tc.expected: The property is parse successfully
1077 */
1078 svgStop->ParseAndSetSpecializedAttr("stop-color", "rgba(0,49,83,255)");
1079 EXPECT_EQ(svgStop->stopAttr_.gradientColor.GetColor().GetValue(), 0xFF003153);
1080
1081 svgStop->ParseAndSetSpecializedAttr("stop-color", "rgb(0,49,83)");
1082 EXPECT_EQ(svgStop->stopAttr_.gradientColor.GetColor().GetValue(), 0xFF003153);
1083
1084 /* *
1085 * @tc.steps: step3. parse stopcolor
1086 * @tc.expected: The property is parse successfully
1087 */
1088 svgStop->ParseAndSetSpecializedAttr("stopColor", "rgb(49,49,83)");
1089 EXPECT_EQ(svgStop->stopAttr_.gradientColor.GetColor().GetValue(), 0xFF313153);
1090
1091 /* *
1092 * @tc.steps: step4. parse stopOpacity
1093 * @tc.expected: The property is parse successfully
1094 */
1095 svgStop->ParseAndSetSpecializedAttr("stopOpacity", "0.0");
1096 EXPECT_EQ(svgStop->GetGradientColor().GetOpacity(), 0.0);
1097
1098 /* *
1099 * @tc.steps: step5. parse properties that do not belong to SvgStop
1100 * @tc.expected: The property is parse unsuccessfully
1101 */
1102 bool parseResult = svgStop->ParseAndSetSpecializedAttr("strokeLinecap", "butt");
1103 EXPECT_FALSE(parseResult);
1104 MockContainer::Current()->SetApiTargetVersion(backupApiVersion);
1105 }
1106
1107 /**
1108 * @tc.name: ParseFeTest001
1109 * @tc.desc: parse fe label
1110 * @tc.type: FUNC
1111 */
1112 HWTEST_F(ParseTestTwoNg, ParseFeTest001, TestSize.Level1)
1113 {
1114 /* *
1115 * @tc.steps: step1. create fe node
1116 */
1117 auto svgFe = AccessibilityManager::MakeRefPtr<SvgFe>();
1118
1119 svgFe->ParseAndSetSpecializedAttr("color-interpolation-filters", "auto");
1120 EXPECT_EQ(svgFe->feAttr_.colorInterpolationType, SvgColorInterpolationType::AUTO);
1121
1122 svgFe->ParseAndSetSpecializedAttr("color-interpolation-filters", "SRGB");
1123 EXPECT_EQ(svgFe->feAttr_.colorInterpolationType, SvgColorInterpolationType::AUTO);
1124
1125 svgFe->ParseAndSetSpecializedAttr("height", "1px");
1126 EXPECT_EQ(svgFe->feAttr_.height, 1.0_px);
1127
1128 svgFe->ParseAndSetSpecializedAttr("width", "1px");
1129 EXPECT_EQ(svgFe->feAttr_.width, 1.0_px);
1130
1131 svgFe->ParseAndSetSpecializedAttr("x", "1px");
1132 EXPECT_EQ(svgFe->feAttr_.x, 1.0_px);
1133
1134 svgFe->ParseAndSetSpecializedAttr("y", "1px");
1135 EXPECT_EQ(svgFe->feAttr_.y, 1.0_px);
1136
1137 bool parseResult = svgFe->ParseAndSetSpecializedAttr("strokeLinecap", "butt");
1138 EXPECT_FALSE(parseResult);
1139
1140 std::shared_ptr<RSImageFilter> imageFilter = nullptr;
1141 SvgColorInterpolationType colorInterpolationType = SvgColorInterpolationType::SRGB;
1142 svgFe->GetImageFilter(imageFilter, colorInterpolationType, resultHash);
1143 EXPECT_EQ(svgFe->effectFilterArea_.Top(), 0.0f);
1144 EXPECT_EQ(svgFe->effectFilterArea_.Left(), 0.0f);
1145 }
1146
1147 /**
1148 * @tc.name: ParseFeBlenderTest001
1149 * @tc.desc: test fe blender
1150 * @tc.type: FUNC
1151 */
1152 HWTEST_F(ParseTestTwoNg, ParseFeBlenderTest001, TestSize.Level1)
1153 {
1154 /* *
1155 * @tc.steps: step1. create feBlend node
1156 */
1157 auto svgFeBlend = AccessibilityManager::MakeRefPtr<SvgFeBlend>();
1158
1159 svgFeBlend->ParseAndSetSpecializedAttr("in2", "undefine");
1160 SvgFeBlendAttribute svgFeBlendDeclaration = svgFeBlend->feBlendAttr_;
1161 EXPECT_EQ(svgFeBlendDeclaration.in2.id, "undefine");
1162 svgFeBlend->ParseAndSetSpecializedAttr("mode", "undefine");
1163 svgFeBlendDeclaration = svgFeBlend->feBlendAttr_;
1164 EXPECT_EQ(svgFeBlendDeclaration.blendMode, SvgFeBlendMode::NORMAL);
1165
1166 RSBlendMode rsBlendMode = svgFeBlend->GetBlendMode(SvgFeBlendMode::NORMAL);
1167 EXPECT_EQ(rsBlendMode, RSBlendMode::SRC_OVER);
1168 rsBlendMode = svgFeBlend->GetBlendMode(SvgFeBlendMode::MULTIPLY);
1169 EXPECT_EQ(rsBlendMode, RSBlendMode::MULTIPLY);
1170 rsBlendMode = svgFeBlend->GetBlendMode(SvgFeBlendMode::SCREEN);
1171 EXPECT_EQ(rsBlendMode, RSBlendMode::SCREEN);
1172 rsBlendMode = svgFeBlend->GetBlendMode(SvgFeBlendMode::DARKEN);
1173 EXPECT_EQ(rsBlendMode, RSBlendMode::DARKEN);
1174 rsBlendMode = svgFeBlend->GetBlendMode(SvgFeBlendMode::LIGHTEN);
1175 EXPECT_EQ(rsBlendMode, RSBlendMode::LIGHTEN);
1176 rsBlendMode = svgFeBlend->GetBlendMode(static_cast<SvgFeBlendMode>(8));
1177 EXPECT_EQ(rsBlendMode, RSBlendMode::SRC_OVER);
1178 }
1179
1180 /**
1181 * @tc.name: ParseFeColorMatrixTest001
1182 * @tc.desc: parse FeColorMatrix label
1183 * @tc.type: FUNC
1184 */
1185 HWTEST_F(ParseTestTwoNg, ParseFeColorMatrixTest001, TestSize.Level1)
1186 {
1187 auto svgStream = SkMemoryStream::MakeCopy(FE_COLOR_MATRIX.c_str(), FE_COLOR_MATRIX.length());
1188 EXPECT_NE(svgStream, nullptr);
1189 ImageSourceInfo src;
1190 src.SetFillColor(Color::BLACK);
1191 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1192 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1193 EXPECT_GT(svg->children_.size(), 0);
1194 // filter is first child in svg
1195 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
1196 EXPECT_NE(svgFilter, nullptr);
1197 // the first child in filter
1198 auto svgFeColorMatrix1 = AceType::DynamicCast<SvgFeColorMatrix>(svgFilter->children_.at(0));
1199 EXPECT_NE(svgFeColorMatrix1, nullptr);
1200 svgFeColorMatrix1->OnInitStyle();
1201 auto feColorDeclaration1 = svgFeColorMatrix1->matrixAttr_;
1202 EXPECT_EQ(feColorDeclaration1.type, SvgFeColorMatrixType::MATRIX);
1203 // the second child in filter
1204 auto svgFeColorMatrix2 = AceType::DynamicCast<SvgFeColorMatrix>(svgFilter->children_.at(1));
1205 EXPECT_NE(svgFeColorMatrix2, nullptr);
1206 svgFeColorMatrix2->OnInitStyle();
1207 auto feColorDeclaration2 = svgFeColorMatrix2->matrixAttr_;
1208 EXPECT_EQ(feColorDeclaration2.type, SvgFeColorMatrixType::SATURATE);
1209 // the third child in filter
1210 auto svgFeColorMatrix3 = AceType::DynamicCast<SvgFeColorMatrix>(svgFilter->children_.at(2));
1211 EXPECT_NE(svgFeColorMatrix3, nullptr);
1212 svgFeColorMatrix3->OnInitStyle();
1213 auto feColorDeclaration3 = svgFeColorMatrix3->matrixAttr_;
1214 EXPECT_EQ(feColorDeclaration3.type, SvgFeColorMatrixType::HUE_ROTATE);
1215 // the fourth child in filter
1216 auto svgFeColorMatrix4 = AceType::DynamicCast<SvgFeColorMatrix>(svgFilter->children_.at(3));
1217 EXPECT_NE(svgFeColorMatrix4, nullptr);
1218 svgFeColorMatrix4->OnInitStyle();
1219 auto feColorDeclaration4 = svgFeColorMatrix4->matrixAttr_;
1220 EXPECT_EQ(feColorDeclaration4.type, SvgFeColorMatrixType::LUMINACE_TO_ALPHA);
1221 // the fifth child in filter
1222 auto svgFeColorMatrix5 = AceType::DynamicCast<SvgFeColorMatrix>(svgFilter->children_.at(4));
1223 EXPECT_NE(svgFeColorMatrix5, nullptr);
1224 svgFeColorMatrix5->OnInitStyle();
1225 auto feColorDeclaration5 = svgFeColorMatrix5->matrixAttr_;
1226 EXPECT_EQ(feColorDeclaration5.type, SvgFeColorMatrixType::MATRIX);
1227 }
1228
1229 /**
1230 * @tc.name: ParseFeCompositeTest001
1231 * @tc.desc: parse Composite label
1232 * @tc.type: FUNC
1233 */
1234 HWTEST_F(ParseTestTwoNg, ParseFeCompositeTest001, TestSize.Level1)
1235 {
1236 auto svgStream = SkMemoryStream::MakeCopy(FE_COMPOSITE.c_str(), FE_COMPOSITE.length());
1237 EXPECT_NE(svgStream, nullptr);
1238 ImageSourceInfo src;
1239 src.SetFillColor(Color::BLACK);
1240 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1241 EXPECT_NE(svgDom, nullptr);
1242 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1243 EXPECT_GT(svg->children_.size(), 0);
1244 // filter is first child in svg
1245 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
1246 EXPECT_NE(svgFilter, nullptr);
1247 // the first child in filter
1248 auto svgFeComposite1 = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(0));
1249 EXPECT_NE(svgFeComposite1, nullptr);
1250 svgFeComposite1->ParseAndSetSpecializedAttr("operator", "undefine");
1251 SvgFeCompositeAttribute svgFeCompositeDeclaration = svgFeComposite1->feCompositeAttr_;
1252 EXPECT_EQ(svgFeCompositeDeclaration.operatorType, SvgFeOperatorType::FE_OVER);
1253
1254 std::shared_ptr<RSImageFilter> imageFilter = nullptr;
1255 SvgColorInterpolationType srcColor = SvgColorInterpolationType::SRGB;
1256 SvgColorInterpolationType currentColor = SvgColorInterpolationType::LINEAR_RGB;
1257 svgFeComposite1->feCompositeAttr_.operatorType = static_cast<SvgFeOperatorType>(8);
1258 svgFeComposite1->OnAsImageFilter(imageFilter, srcColor, currentColor, resultHash);
1259 RSBlendMode rsBlendMode = svgFeComposite1->BlendModeForOperator(SvgFeOperatorType::FE_ARITHMETIC);
1260 EXPECT_EQ(rsBlendMode, RSBlendMode::SRC_OVER);
1261
1262 auto svgFeComposite5 = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(4));
1263 EXPECT_NE(svgFeComposite5, nullptr);
1264 svgFeComposite5->OnAsImageFilter(imageFilter, srcColor, currentColor, resultHash);
1265 svgFeCompositeDeclaration = svgFeComposite5->feCompositeAttr_;
1266 EXPECT_EQ(svgFeCompositeDeclaration.operatorType, SvgFeOperatorType::FE_LIGHTER);
1267
1268 auto svgFeComposite6 = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(5));
1269 EXPECT_NE(svgFeComposite6, nullptr);
1270 svgFeComposite6->OnAsImageFilter(imageFilter, srcColor, currentColor, resultHash);
1271 svgFeCompositeDeclaration = svgFeComposite6->feCompositeAttr_;
1272 EXPECT_EQ(svgFeCompositeDeclaration.operatorType, SvgFeOperatorType::FE_OUT);
1273
1274 auto svgFeComposite7 = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(6));
1275 EXPECT_NE(svgFeComposite7, nullptr);
1276 svgFeComposite7->OnAsImageFilter(imageFilter, srcColor, currentColor, resultHash);
1277 svgFeCompositeDeclaration = svgFeComposite7->feCompositeAttr_;
1278 EXPECT_EQ(svgFeCompositeDeclaration.operatorType, SvgFeOperatorType::FE_XOR);
1279
1280 auto svgFeComposite8 = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(7));
1281 EXPECT_NE(svgFeComposite8, nullptr);
1282 svgFeComposite8->OnAsImageFilter(imageFilter, srcColor, currentColor, resultHash);
1283 svgFeCompositeDeclaration = svgFeComposite8->feCompositeAttr_;
1284 EXPECT_EQ(svgFeCompositeDeclaration.operatorType, SvgFeOperatorType::FE_OVER);
1285 }
1286
1287 /**
1288 * @tc.name: ParseFeCompositeTest002
1289 * @tc.desc: parse Composite label
1290 * @tc.type: FUNC
1291 */
1292 HWTEST_F(ParseTestTwoNg, ParseFeCompositeTest002, TestSize.Level1)
1293 {
1294 auto svgStream = SkMemoryStream::MakeCopy(FE_COMPOSITE.c_str(), FE_COMPOSITE.length());
1295 EXPECT_NE(svgStream, nullptr);
1296 ImageSourceInfo src;
1297 src.SetFillColor(Color::BLACK);
1298 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1299 EXPECT_NE(svgDom, nullptr);
1300 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1301 EXPECT_GT(svg->children_.size(), 0);
1302 // filter is first child in svg
1303 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
1304 EXPECT_NE(svgFilter, nullptr);
1305
1306 std::shared_ptr<RSImageFilter> imageFilter = nullptr;
1307 SvgColorInterpolationType srcColor = SvgColorInterpolationType::SRGB;
1308 SvgColorInterpolationType currentColor = SvgColorInterpolationType::LINEAR_RGB;
1309 auto svgFeComposite5 = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(4));
1310 EXPECT_NE(svgFeComposite5, nullptr);
1311 svgFeComposite5->OnAsImageFilter(imageFilter, srcColor, currentColor, resultHash);
1312 SvgFeCompositeAttribute svgFeCompositeDeclaration = svgFeComposite5->feCompositeAttr_;
1313 EXPECT_EQ(svgFeCompositeDeclaration.operatorType, SvgFeOperatorType::FE_LIGHTER);
1314
1315 auto svgFeComposite6 = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(5));
1316 EXPECT_NE(svgFeComposite6, nullptr);
1317 svgFeComposite6->OnAsImageFilter(imageFilter, srcColor, currentColor, resultHash);
1318 svgFeCompositeDeclaration = svgFeComposite6->feCompositeAttr_;
1319 EXPECT_EQ(svgFeCompositeDeclaration.operatorType, SvgFeOperatorType::FE_OUT);
1320
1321 auto svgFeComposite7 = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(6));
1322 EXPECT_NE(svgFeComposite7, nullptr);
1323 svgFeComposite7->OnAsImageFilter(imageFilter, srcColor, currentColor, resultHash);
1324 svgFeCompositeDeclaration = svgFeComposite7->feCompositeAttr_;
1325 EXPECT_EQ(svgFeCompositeDeclaration.operatorType, SvgFeOperatorType::FE_XOR);
1326
1327 auto svgFeComposite8 = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(7));
1328 EXPECT_NE(svgFeComposite8, nullptr);
1329 svgFeComposite8->OnAsImageFilter(imageFilter, srcColor, currentColor, resultHash);
1330 svgFeCompositeDeclaration = svgFeComposite8->feCompositeAttr_;
1331 EXPECT_EQ(svgFeCompositeDeclaration.operatorType, SvgFeOperatorType::FE_OVER);
1332 }
1333
1334 HWTEST_F(ParseTestTwoNg, ParseFeGaussianBlurTest001, TestSize.Level1)
1335 {
1336 auto svgStream = SkMemoryStream::MakeCopy(FE_GAUSSIAN_BLUR.c_str(), FE_GAUSSIAN_BLUR.length());
1337 EXPECT_NE(svgStream, nullptr);
1338 ImageSourceInfo src;
1339 src.SetFillColor(Color::BLACK);
1340 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1341 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1342 EXPECT_GT(svg->children_.size(), 0);
1343 // filter is first child in svg
1344 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
1345 EXPECT_NE(svgFilter, nullptr);
1346 // the first child in filter
1347 auto svgFeGaussianBlur1 = AceType::DynamicCast<SvgFeGaussianBlur>(svgFilter->children_.at(0));
1348 EXPECT_NE(svgFeGaussianBlur1, nullptr);
1349
1350 auto bResult = svgFeGaussianBlur1->ParseAndSetSpecializedAttr("stddeviation", "");
1351 EXPECT_TRUE(bResult);
1352 }
1353
1354 /**
1355 * @tc.name: ParseFeOffsetTest001
1356 * @tc.desc: test fe offset
1357 * @tc.type: FUNC
1358 */
1359 HWTEST_F(ParseTestTwoNg, ParseFeOffsetTest001, TestSize.Level1)
1360 {
1361 /* *
1362 * @tc.steps: step1. create feOffset node
1363 */
1364 auto svgFeOffset = AccessibilityManager::MakeRefPtr<SvgFeOffset>();
1365
1366 svgFeOffset->ParseAndSetSpecializedAttr("dx", "5");
1367 auto svgFeOffsetAttribute = svgFeOffset->feOffsetAttr_;
1368 EXPECT_EQ(svgFeOffsetAttribute.dx, Dimension(5));
1369
1370 auto bResult = svgFeOffset->ParseAndSetSpecializedAttr("undefine", "undefine");
1371 EXPECT_FALSE(bResult);
1372 }
1373
1374 /**
1375 * @tc.name: ParseMaskTest001
1376 * @tc.desc: test Mask
1377 * @tc.type: FUNC
1378 */
1379 HWTEST_F(ParseTestTwoNg, ParseMaskTest001, TestSize.Level1)
1380 {
1381 /* *
1382 * @tc.steps: step1. create svgMask node
1383 */
1384 auto svgMask = AceType::DynamicCast<SvgMask>(SvgMask::Create());
1385 EXPECT_NE(svgMask, nullptr);
1386
1387 svgMask->ParseAndSetSpecializedAttr("y", "5");
1388 auto svgMaskAttribute = svgMask->maskAttr_;
1389 EXPECT_EQ(svgMaskAttribute.y, Dimension(5));
1390 auto attrValue = svgMask->ParseUnitsAttr(Dimension(1.0, DimensionUnit::PERCENT), 2.0);
1391 EXPECT_EQ(attrValue, 2.0);
1392 attrValue = svgMask->ParseUnitsAttr(Dimension(1.0), 2.0);
1393 EXPECT_EQ(attrValue, 2.0);
1394
1395 svgMask->isDefaultMaskUnits_ = false;
1396 attrValue = svgMask->ParseUnitsAttr(Dimension(1.0), 2.0);
1397 EXPECT_EQ(attrValue, 1.0);
1398 attrValue = svgMask->ParseUnitsAttr(Dimension(1.0, DimensionUnit::PERCENT), 2.0);
1399 EXPECT_EQ(attrValue, 2.0);
1400 }
1401
1402 /**
1403 * @tc.name: ParseRectTest005
1404 * @tc.desc: parse rect label
1405 * @tc.type: FUNC
1406 */
1407 HWTEST_F(ParseTestTwoNg, ParseRectTest005, TestSize.Level1)
1408 {
1409 auto svgStream = SkMemoryStream::MakeCopy(RECT_SVG_LABEL4.c_str(), RECT_SVG_LABEL4.length());
1410 ImageSourceInfo src;
1411 src.SetFillColor(Color::BLACK);
1412 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1413 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1414 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
1415
1416 /* *
1417 * @tc.steps: step1. call AsPath
1418 * @tc.expected: Execute function return value not is 0
1419 */
1420 auto svgRect = AceType::DynamicCast<SvgRect>(svg->children_.at(0));
1421 EXPECT_NE(svgRect, nullptr);
1422 svgRect->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1423 auto rectDeclaration = svgRect->rectAttr_;
1424 EXPECT_NE(rectDeclaration.rx.Value(), 0);
1425 }
1426
1427 /**
1428 * @tc.name: ParseUseTest003
1429 * @tc.desc: parse use label
1430 * @tc.type: FUNC
1431 */
1432 HWTEST_F(ParseTestTwoNg, ParseUseTest003, TestSize.Level1)
1433 {
1434 auto svgStream = SkMemoryStream::MakeCopy(USE_SVG_LABEL.c_str(), USE_SVG_LABEL.length());
1435 EXPECT_NE(svgStream, nullptr);
1436
1437 ImageSourceInfo src;
1438 src.SetFillColor(Color::GREEN);
1439
1440 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1441 EXPECT_NE(svgDom, nullptr);
1442
1443 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1444 EXPECT_NE(svg, nullptr);
1445 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
1446
1447 auto svgUse = AceType::DynamicCast<SvgUse>(svg->children_.at(INDEX_ONE));
1448 EXPECT_NE(svgUse, nullptr);
1449
1450 Testing::MockCanvas rSCanvas;
1451 CallBack(rSCanvas);
1452 svgUse->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1453 svgUse->useAttr_.x = Dimension(1.0, DimensionUnit::PERCENT);
1454 svgUse->useAttr_.y = Dimension(1.0, DimensionUnit::PERCENT);
1455 svgUse->OnDraw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
1456 svgUse->useAttr_.x = Dimension(0.0, DimensionUnit::PERCENT);
1457 svgUse->OnDraw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
1458 svgUse->attributes_.href = "";
1459 svgUse->OnDraw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
1460
1461 auto bResult = svgUse->ParseAndSetSpecializedAttr("viewBox", "");
1462 EXPECT_TRUE(bResult);
1463
1464 svgUse->ParseAndSetSpecializedAttr("viewBox", "0 0 0 10");
1465 EXPECT_EQ(svgUse->useAttr_.viewBox.Height(), 10.0);
1466 svgUse->ParseAndSetSpecializedAttr("viewBox", "0 0 10");
1467 EXPECT_EQ(svgUse->useAttr_.viewBox.Height(), 10.0);
1468
1469 bResult = svgUse->ParseAndSetSpecializedAttr("viewbox", "");
1470 EXPECT_TRUE(bResult);
1471
1472 svgUse->ParseAndSetSpecializedAttr("viewbox", "0 0 24");
1473 EXPECT_EQ(svgUse->useAttr_.viewBox.Width(), 0.0);
1474 svgUse->ParseAndSetSpecializedAttr("viewbox", "0 0 10 10");
1475 EXPECT_EQ(svgUse->useAttr_.viewBox.Width(), 10.0);
1476
1477 bResult = svgUse->ParseAndSetSpecializedAttr("undefine", "");
1478 EXPECT_FALSE(bResult);
1479 }
1480
1481 /**
1482 * @tc.name: ParseSvgTest001
1483 * @tc.desc: parse svg label
1484 * @tc.type: FUNC
1485 */
1486 HWTEST_F(ParseTestTwoNg, ParseSvgTest001, TestSize.Level1)
1487 {
1488 auto svgStream = SkMemoryStream::MakeCopy(USE_SVG_LABEL.c_str(), USE_SVG_LABEL.length());
1489 EXPECT_NE(svgStream, nullptr);
1490
1491 ImageSourceInfo src;
1492 src.SetFillColor(Color::GREEN);
1493
1494 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1495 EXPECT_NE(svgDom, nullptr);
1496
1497 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1498 EXPECT_NE(svg, nullptr);
1499
1500 Testing::MockCanvas rSCanvas;
1501 EXPECT_CALL(rSCanvas, AttachBrush(_)).WillRepeatedly(ReturnRef(rSCanvas));
1502 EXPECT_CALL(rSCanvas, DetachBrush()).WillRepeatedly(ReturnRef(rSCanvas));
1503 EXPECT_CALL(rSCanvas, AttachPen(_)).WillRepeatedly(ReturnRef(rSCanvas));
1504 EXPECT_CALL(rSCanvas, DetachPen()).WillRepeatedly(ReturnRef(rSCanvas));
1505
1506 svg->svgAttr_.width = Dimension(1.0);
1507 svg->svgAttr_.height = Dimension(-1.0);
1508 svg->AdjustContentAreaByViewBox(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1509 svg->svgAttr_.height = Dimension(1.0);
1510 svg->svgAttr_.width = Dimension(-1.0);
1511 svg->AdjustContentAreaByViewBox(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1512 svg->svgAttr_.height = Dimension(-1.0);
1513 svg->AdjustContentAreaByViewBox(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1514 svg->svgAttr_.viewBox.height_ = 0.0;
1515 svg->AdjustContentAreaByViewBox(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1516 svg->svgAttr_.viewBox.width_ = 0.0;
1517 svg->AdjustContentAreaByViewBox(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1518
1519 auto bResult = svg->ParseAndSetSpecializedAttr("viewBox", "");
1520 EXPECT_TRUE(bResult);
1521 svg->ParseAndSetSpecializedAttr("viewBox", "0 0 10");
1522 EXPECT_EQ(svg->GetViewBox().Height(), 0.0);
1523 svg->ParseAndSetSpecializedAttr("viewBox", "0 0 0 10");
1524 EXPECT_EQ(svg->GetViewBox().Height(), 10.0);
1525 svg->ParseAndSetSpecializedAttr("viewbox", "0 0 10");
1526 EXPECT_EQ(svg->GetViewBox().Width(), 0.0);
1527 svg->ParseAndSetSpecializedAttr("viewbox", "0 0 10 10");
1528 EXPECT_EQ(svg->GetViewBox().Width(), 10.0);
1529 bResult = svg->ParseAndSetSpecializedAttr("viewbox", "");
1530 EXPECT_TRUE(bResult);
1531 }
1532
1533 /**
1534 * @tc.name: ParsePathTest001
1535 * @tc.desc: parse path label
1536 * @tc.type: FUNC
1537 */
1538 HWTEST_F(ParseTestTwoNg, ParsePathTest001, TestSize.Level1)
1539 {
1540 auto svgStream = SkMemoryStream::MakeCopy(PATH_SVG_LABEL1.c_str(), PATH_SVG_LABEL1.length());
1541 EXPECT_NE(svgStream, nullptr);
1542
1543 ImageSourceInfo src;
1544 src.SetFillColor(Color::BLACK);
1545
1546 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1547 EXPECT_NE(svgDom, nullptr);
1548
1549 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1550 EXPECT_NE(svg, nullptr);
1551 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
1552
1553 auto svgPath = AceType::DynamicCast<SvgPath>(svg->children_.at(0));
1554 EXPECT_NE(svgPath, nullptr);
1555
1556 svgPath->attributes_.fillState.SetFillRule("evenodd");
1557 svgPath->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1558 EXPECT_TRUE(svgPath->attributes_.fillState.IsEvenodd());
1559
1560 svgPath->d_ = "";
1561 svgPath->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1562 EXPECT_TRUE(svgPath->d_.empty());
1563 }
1564
1565 /**
1566 * @tc.name: ParseFeTest002
1567 * @tc.desc: Test SvgFe Method
1568 * @tc.type: FUNC
1569 */
1570 HWTEST_F(ParseTestTwoNg, ParseFeTest002, TestSize.Level1)
1571 {
1572 /* *
1573 * @tc.steps: step1. call MakeRefPtr<SvgFe>()
1574 * @tc.expected: Execute function return value not is nullptr
1575 */
1576 auto svgFe = AccessibilityManager::MakeRefPtr<SvgFe>();
1577 EXPECT_NE(svgFe, nullptr);
1578
1579 /* *
1580 * @tc.steps: step2. call MakeImageFilter
1581 * @tc.expected: Execute function return value not is nullptr
1582 */
1583 std::shared_ptr<RSImageFilter> imageFilter = nullptr;
1584 SvgFeIn in = {
1585 .in = SvgFeInType::SOURCE_GRAPHIC,
1586 .id = "test"
1587 };
1588
1589 in.in = SvgFeInType::PRIMITIVE;
1590 auto value = svgFe->MakeImageFilter(in, imageFilter, resultHash);
1591 EXPECT_EQ(value, nullptr);
1592
1593 /* *
1594 * @tc.steps: step3. call RegisterResult
1595 * @tc.expected: Register Successfully
1596 */
1597 svgFe->RegisterResult("test", imageFilter, resultHash);
1598 EXPECT_TRUE(resultHash.find("test") != resultHash.end());
1599
1600 SvgColorInterpolationType colorInterpolationType = SvgColorInterpolationType::SRGB;
1601 svgFe->feAttr_.in.in = SvgFeInType::SOURCE_GRAPHIC;
1602 svgFe->GetImageFilter(imageFilter, colorInterpolationType, resultHash);
1603
1604 colorInterpolationType = SvgColorInterpolationType::LINEAR_RGB;
1605 SvgColorInterpolationType srcColor = SvgColorInterpolationType::LINEAR_RGB;
1606 svgFe->ConverImageFilterColor(imageFilter, srcColor, colorInterpolationType);
1607
1608 value = svgFe->MakeImageFilter(in, imageFilter, resultHash);
1609 EXPECT_EQ(value, nullptr);
1610 }
1611
1612 /**
1613 * @tc.name: ParsePatternTest001
1614 * @tc.desc: parse pattern label
1615 * @tc.type: FUNC
1616 */
1617 HWTEST_F(ParseTestTwoNg, ParsePatternTest001, TestSize.Level1)
1618 {
1619 auto svgStream = SkMemoryStream::MakeCopy(PATTERN_SVG_LABEL.c_str(), PATTERN_SVG_LABEL.length());
1620 EXPECT_NE(svgStream, nullptr);
1621
1622 ImageSourceInfo src;
1623 src.SetFillColor(Color::BLACK);
1624
1625 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1626 EXPECT_NE(svgDom, nullptr);
1627
1628 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1629 EXPECT_NE(svg, nullptr);
1630 EXPECT_GT(svg->children_.size(), 0);
1631
1632 auto svgDefs = AceType::DynamicCast<SvgDefs>(svg->children_.at(0));
1633 EXPECT_NE(svgDefs, nullptr);
1634
1635 auto svgPattern = AceType::DynamicCast<SvgPattern>(svgDefs->children_.at(0));
1636 EXPECT_NE(svgPattern, nullptr);
1637 auto patternDeclaration = svgPattern->patternAttr_;
1638
1639 Testing::MockCanvas rSCanvas;
1640 EXPECT_CALL(rSCanvas, AttachBrush(_)).WillRepeatedly(ReturnRef(rSCanvas));
1641 EXPECT_CALL(rSCanvas, DetachBrush()).WillRepeatedly(ReturnRef(rSCanvas));
1642 EXPECT_CALL(rSCanvas, AttachPen(_)).WillRepeatedly(ReturnRef(rSCanvas));
1643 EXPECT_CALL(rSCanvas, DetachPen()).WillRepeatedly(ReturnRef(rSCanvas));
1644
1645 int32_t settingApiVersion = static_cast<int32_t>(PlatformVersion::VERSION_FOURTEEN);
1646 int32_t backupApiVersion = MockContainer::Current()->GetApiTargetVersion();
1647 MockContainer::Current()->SetApiTargetVersion(settingApiVersion);
1648
1649 svgPattern->OnDrawTraversedBefore(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
1650
1651 MockContainer::Current()->SetApiTargetVersion(backupApiVersion);
1652
1653 svgPattern->ParseAndSetSpecializedAttr("viewbox", "");
1654 svgPattern->ParseAndSetSpecializedAttr("viewbox", "0 0 24");
1655 EXPECT_EQ(patternDeclaration.viewBox.Width(), 10.0);
1656 EXPECT_EQ(patternDeclaration.viewBox.Height(), 10.0);
1657 }
1658
1659 /**
1660 * @tc.name: ParseFilterTest001
1661 * @tc.desc: parse Filter label
1662 * @tc.type: FUNC
1663 */
1664 HWTEST_F(ParseTestTwoNg, ParseFilterTest001, TestSize.Level1)
1665 {
1666 auto svgStream = SkMemoryStream::MakeCopy(COMPOSITE_SVG_LABEL.c_str(), COMPOSITE_SVG_LABEL.length());
1667 EXPECT_NE(svgStream, nullptr);
1668
1669 ImageSourceInfo src;
1670 src.SetFillColor(Color::BLACK);
1671
1672 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1673 EXPECT_NE(svgDom, nullptr);
1674
1675 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1676 EXPECT_NE(svg, nullptr);
1677 EXPECT_GT(svg->children_.size(), 0);
1678
1679 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
1680 EXPECT_NE(svgFilter, nullptr);
1681
1682 auto svgFeComposite = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(0));
1683 EXPECT_NE(svgFeComposite, nullptr);
1684
1685 svgFilter->filterAttr_.height = Dimension(1.0, DimensionUnit::PX);
1686 svgFilter->filterAttr_.width = Dimension(1.0, DimensionUnit::PX);
1687 svgFilter->filterAttr_.x = Dimension(1.0, DimensionUnit::PX);
1688 svgFilter->filterAttr_.y = Dimension(1.0, DimensionUnit::PX);
1689 svgFilter->OnAsPaint();
1690 EXPECT_EQ(svgFeComposite->effectFilterArea_.x_, 1.0);
1691 EXPECT_EQ(svgFeComposite->effectFilterArea_.y_, 1.0);
1692 EXPECT_EQ(svgFeComposite->effectFilterArea_.width_, 1.0);
1693 EXPECT_EQ(svgFeComposite->effectFilterArea_.height_, 1.0);
1694
1695 svgFilter->filterAttr_.height = Dimension(1.0, DimensionUnit::PERCENT);
1696 svgFilter->filterAttr_.width = Dimension(1.0, DimensionUnit::PERCENT);
1697 svgFilter->filterAttr_.x = Dimension(1.0, DimensionUnit::PERCENT);
1698 svgFilter->filterAttr_.y = Dimension(1.0, DimensionUnit::PERCENT);
1699 svgFilter->OnAsPaint();
1700 EXPECT_EQ(svgFeComposite->effectFilterArea_.x_, 0);
1701 EXPECT_EQ(svgFeComposite->effectFilterArea_.y_, 0);
1702 EXPECT_EQ(svgFeComposite->effectFilterArea_.width_, 0);
1703 EXPECT_EQ(svgFeComposite->effectFilterArea_.height_, 0);
1704 }
1705
1706 /**
1707 * @tc.name: ParseFilterTest002
1708 * @tc.desc: parse Filter label
1709 * @tc.type: FUNC
1710 */
1711 HWTEST_F(ParseTestTwoNg, ParseFilterTest002, TestSize.Level1)
1712 {
1713 auto svgStream = SkMemoryStream::MakeCopy(FE_COLOR_MATRIX.c_str(), FE_COLOR_MATRIX.length());
1714 EXPECT_NE(svgStream, nullptr);
1715
1716 ImageSourceInfo src;
1717 src.SetFillColor(Color::BLACK);
1718
1719 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1720 EXPECT_NE(svgDom, nullptr);
1721
1722 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1723 EXPECT_NE(svg, nullptr);
1724 EXPECT_GT(svg->children_.size(), 0);
1725
1726 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
1727 EXPECT_NE(svgFilter, nullptr);
1728
1729 svgFilter->children_.at(0) = nullptr;
1730 svgFilter->OnAsPaint();
1731 auto nodeFe1 = AceType::DynamicCast<SvgFe>(svgFilter->children_.at(0));
1732 auto nodeFe2 = AceType::DynamicCast<SvgFe>(svgFilter->children_.at(1));
1733 EXPECT_EQ(nodeFe1, nullptr);
1734 EXPECT_NE(nodeFe2, nullptr);
1735 }
1736
1737 /**
1738 * @tc.name: ParseNodeTest006
1739 * @tc.desc: Test SvgNode SetAttr Parameters
1740 * @tc.type: FUNC
1741 */
1742 HWTEST_F(ParseTestTwoNg, ParseNodeTest006, TestSize.Level1)
1743 {
1744 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
1745 svgNode->SetAttr("fill", "url(#test)");
1746 EXPECT_EQ(svgNode->GetBaseAttributes().fillState.GetHref(), "test");
1747
1748 int32_t settingApiVersion = static_cast<int32_t>(PlatformVersion::VERSION_FOURTEEN);
1749 int32_t backupApiVersion = MockContainer::Current()->GetApiTargetVersion();
1750 MockContainer::Current()->SetApiTargetVersion(settingApiVersion);
1751
1752 svgNode->SetAttr("stroke", "#test");
1753
1754 MockContainer::Current()->SetApiTargetVersion(backupApiVersion);
1755
1756 svgNode->SetAttr("stroke", "url(#test)");
1757
1758 svgNode->InitStyle(SvgBaseAttribute());
1759 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetHref(), "test");
1760 }
1761
1762 /**
1763 * @tc.name: ParseNodeTest007
1764 * @tc.desc: Test SvgNode SetAttr Parameters
1765 * @tc.type: FUNC
1766 */
1767 HWTEST_F(ParseTestTwoNg, ParseNodeTest007, TestSize.Level1)
1768 {
1769 auto svgStream = SkMemoryStream::MakeCopy(GRADIENT_SVG_LINEAR.c_str(), GRADIENT_SVG_LINEAR.length());
1770 EXPECT_NE(svgStream, nullptr);
1771
1772 ImageSourceInfo src;
1773 src.SetFillColor(Color::BLACK);
1774
1775 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1776 EXPECT_NE(svgDom, nullptr);
1777
1778 svgDom->root_->SetAttr("fill", "url(#grad1)");
1779 svgDom->root_->SetAttr("stroke", "url(#grad1)");
1780 svgDom->root_->InitStyle(SvgBaseAttribute());
1781 EXPECT_EQ(svgDom->root_->GetBaseAttributes().strokeState.GetHref(), "grad1");
1782 EXPECT_EQ(svgDom->root_->GetBaseAttributes().fillState.GetHref(), "grad1");
1783 }
1784
1785 /**
1786 * @tc.name: ParseStyleTest001
1787 * @tc.desc: parse use label
1788 * @tc.type: FUNC
1789 */
1790 HWTEST_F(ParseTestTwoNg, ParseStyleTest001, TestSize.Level1)
1791 {
1792 /* *
1793 * @tc.steps: step1. call ParseCssStyle
1794 * @tc.expected: Execute function return value false
1795 */
1796 std::string str;
__anonf52872f50602(const std::string& key, const std::pair<std::string, std::string>& value) 1797 PushAttr callback = [&str](const std::string& key, const std::pair<std::string, std::string>& value) { str = key; };
1798 SvgStyle::ParseCssStyle("", callback);
1799 EXPECT_TRUE(str.empty());
1800
1801 SvgStyle::ParseCssStyle("body {font-style: oblique;}.normal {font-style: normal;}", callback);
1802 EXPECT_FALSE(str.empty());
1803 }
1804 } // namespace OHOS::Ace::NG
1805