1 /*
2 * Copyright (c) 2024 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 const std::string CLIP_SVG_LABEL =
85 "<svg width=\"120\" height=\"120\" viewBox=\"0 0 120 120\" version=\"1.1\"><defs><clipPath id=\"myClip\"><circle "
86 "cx=\"30\" cy=\"30\" r=\"20\"/><circle cx=\"70\" cy=\"70\" r=\"30\"/></clipPath></defs><rect x=\"10\" y=\"10\" "
87 "width=\"100\" height=\"100\" clip-path=\"url(#myClip)\" fill=\"red\" /></svg>";
88 const std::string ID = "myClip";
89 const std::string SVG_LABEL = "<svg width=\"400\" height=\"500\" viewBox=\"-4 -10 300 300\"></svg>";
90 const std::string USE_SVG_LABEL =
91 "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"24\" height=\"24\" "
92 "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 "
93 "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 "
94 "10.2573593,13.5 11.5,13.5 Z M11.5006868,9 C13.6153489,9 15.5906493,9.84916677 16.9758057,11.3106505 "
95 "C17.3557222,11.7115019 17.3387512,12.3444394 16.9378998,12.724356 C16.5370484,13.1042725 15.9041109,13.0873015 "
96 "15.5241943,12.6864501 C14.5167672,11.62351 13.0663814,11 11.5006868,11 C9.93437756,11 8.48347933,11.6240033 "
97 "7.47603048,12.6876625 C7.09624495,13.0886381 6.46331303,13.105816 6.06233747,12.7260305 C5.66136192,12.3462449 "
98 "5.644184,11.713313 6.02396952,11.3123375 C7.40917586,9.84984392 9.38518621,9 11.5006868,9 Z M11.5002692,4.5 "
99 "C14.7685386,4.5 17.818619,5.90678629 19.9943022,8.33155689 C20.3631417,8.74262367 20.3289097,9.37486259 "
100 "19.9178429,9.74370206 C19.5067762,10.1125415 18.8745372,10.0783095 18.5056978,9.66724276 C16.703513,7.6587313 "
101 "14.1912454,6.5 11.5002692,6.5 C8.80904291,6.5 6.29656204,7.6589485 4.49435171,9.66778779 C4.1255427,10.0788819 "
102 "3.49330631,10.1131607 3.08221221,9.74435171 C2.67111811,9.3755427 2.63683928,8.74330631 3.00564829,8.33221221 "
103 "C5.1813597,5.90704879 8.23169642,4.5 11.5002692,4.5 Z M11.4995363,-5.68434189e-14 C15.8001105,-5.68434189e-14 "
104 "19.8214916,1.76017363 22.7244081,4.81062864 C23.1051374,5.21070819 23.0894509,5.84367883 22.6893714,6.22440812 "
105 "C22.2892918,6.60513741 21.6563212,6.58945092 21.2755919,6.18937136 C18.7465254,3.53176711 15.2469734,2 "
106 "11.4995363,2 C7.75253773,2 4.25335915,3.53140612 1.72434435,6.1884639 C1.34357805,6.58850824 "
107 "0.71060597,6.60413618 0.310561632,6.22336988 C-0.0894827058,5.84260359 -0.105110646,5.2096315 "
108 "0.27565565,4.80958716 C3.1785132,1.75975912 7.19946582,-5.68434189e-14 11.4995363,-5.68434189e-14 "
109 "Z\"/></defs><use fill=\"red\" fill-rule=\"nonzero\" stroke=\"blue\" stroke-width=\"1\" "
110 "transform=\"translate(.5 2.75)\" xlink:href=\"#uxs-a\"/></svg>";
111 const std::string HREF = "uxs-a";
112 const std::string FILL_RULE = "nonzero";
113 const std::string TRANSFORM = "translate(.5 2.75)";
114 constexpr int32_t INDEX_ONE = 1;
115 const std::string STYLE_SVG_LABEL = "<svg viewBox=\"0 0 10 10\"><style>circle{fill:gold;stroke:maroon;stroke-width : "
116 "2px;}</style><circle cx =\"5\" cy=\"5\" r=\"4\" /></svg>";
117 const std::string STOP_SVG_LABEL =
118 "<svg height=\"150\" width=\"400\"><defs><linearGradient id=\"grad1\" x1=\"0%\" y1=\"0%\" x2=\"100%\" "
119 "y2=\"0%\"><stop offset=\"0%\" style=\"stop-color:rgb(255,255,0);stop-opacity:1\" /><stop offset=\"20px\" "
120 "style=\"stop-color:rgb(255,0,0);stop-opacity:1\" /></linearGradient></defs><ellipse cx=\"200\" cy=\"70\" "
121 "rx=\"85\" ry=\"55\" fill=\"url(#grad1)\" /></svg>";
122 constexpr int32_t CHILD_NUMBER = 2;
123 const std::string RECT_SVG_LABEL = "<svg width=\"400\" height=\"400\" version=\"1.1\" fill=\"red\" "
124 "xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"100\" height=\"100\" x=\"150\" "
125 "y=\"20\" stroke-width=\"4\" stroke=\"#000000\" rx=\"10\" ry=\"10\"></rect></svg>";
126 const std::string RECT_SVG_LABEL2 = "<svg version=\"1.1\" fill=\"red\" "
127 "xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"100\" height=\"100\" x=\"150\" "
128 "y=\"20\" stroke-width=\"4\" stroke=\"#000000\" rx=\"10\" ry=\"10\"></rect></svg>";
129 const std::string RECT_SVG_LABEL3 = "<svg version=\"1.1\" fill=\"red\" "
130 "xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"100\" height=\"100\" x=\"150\" "
131 "y=\"20\" stroke-width=\"4\" stroke=\"#000000\" rx=\"1\" ry=\"-1\"></rect></svg>";
132 constexpr float X = 150.0f;
133 constexpr float Y = 20.0f;
134 constexpr float RX = 10.0f;
135 constexpr float RY = 10.0f;
136 constexpr float RECT_WIDTH = 100.0f;
137 constexpr float RECT_HEIGHT = 100.0f;
138 const std::string POLYGON_SVG_LABEL1 =
139 "<svg fill=\"white\" stroke=\"blue\" width=\"800\" height=\"400\" version=\"1.1\" "
140 "xmlns=\"http://www.w3.org/2000/svg\"><polygon points=\"10,110 60,35 60,85 110,10\" "
141 "fill=\"red\"></polygon> <polyline points=\"10,200 60,125 60,175 110,100\" "
142 "stroke-dasharray=\"10 5\" stroke-dashoffset=\"3\"></polyline></svg>";
143 const std::string POLYGON_SVG_LABEL2 =
144 "<svg fill=\"white\" stroke=\"blue\" width=\"300\" 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_POINT = "10,110 60,35 60,85 110,10";
149 const std::string POLYLINE_POINT = "10,200 60,125 60,175 110,100";
150 const std::string PATTERN_SVG_LABEL =
151 "<svg viewBox=\"0 0 230 100\"><defs><pattern id=\"star\" viewBox=\"0 0 10 10\" width=\"10\" "
152 "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\" "
153 "cy=\"50\" r=\"50\" fill=\"url(#star)\" /><circle cx=\"180\" cy=\"50\" r=\"40\" fill=\"none\" stroke-width=\"20\" "
154 "stroke=\"url(#star)\"/> </svg>";
155 const std::string PATH_SVG_LABEL1 =
156 "<svg width=\"400\" height=\"800\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M 10,30 A 20,20 "
157 "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\" "
158 "fill=\"red\"></path></svg>";
159 const std::string PATH_SVG_LABEL2 =
160 "<svg version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M 10,30 A 20,20 "
161 "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\" "
162 "fill=\"red\"></path></svg>";
163 const std::string PATH_SVG_LABEL3 =
164 "<svg width=\"-400\" height=\"-400\" viewBox=\"-4 -10 300 300\" version=\"1.1\" "
165 "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_LABEL4 =
169 "<svg width=\"300\" 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_LABEL5 =
174 "<svg width=\"400\" 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_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";
179 const std::string MASK_SVG_LABEL =
180 "<svg width=\"50px\" height=\"50px\" viewBox=\"0 0 24 24\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" "
181 "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 "
182 "-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 "
183 "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 "
184 "-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\" "
185 "stroke-width=\"1\" fill=\"none\" fill-rule=\"evenodd\"><g><mask id=\"mask-2\" fill=\"#FFFFFF\"><use "
186 "xlink:href=\"#path-1\"></use></mask><use id=\"myId\" fill=\"#FFFFFF\" fill-rule=\"nonzero\" "
187 "xlink:href=\"#path-1\"></use></g></g></svg>";
188 const std::string MASK_ID = "mask-2";
189 const std::string LINE_SVG_LABEL =
190 "<svg width=\"400\" height=\"400\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><line x1=\"10\" x2=\"300\" "
191 "y1=\"50\" y2=\"50\" stroke-width=\"4\" fill=\"white\" stroke=\"blue\"></line></svg>";
192 const std::string GRADIENT_SVG_LINEAR =
193 "<svg height=\"150\" width=\"400\"><defs><linearGradient id=\"grad1\" x1=\"0%\" y1=\"0%\" x2=\"100%\" "
194 "y2=\"0%\"><stop offset=\"0%\" style=\"stop-color:rgb(255,255,0);stop-opacity:1\" /><stop offset=\"100%\" "
195 "style=\"stop-color:rgb(255,0,0);stop-opacity:1\" /></linearGradient></defs><ellipse cx=\"200\" cy=\"70\" "
196 "rx=\"85\" ry=\"55\" fill=\"url(#grad1)\" /></svg>";
197 const std::string GRADIENT_SVG_RADIAL =
198 "<svg height=\"150\" width=\"500\"><defs><radialGradient id=\"grad1\" cx=\"50%\" cy=\"50%\" r=\"50%\" fx=\"50%\" "
199 "fy=\"50%\"><stop offset=\"0%\" style=\"stop-color:rgb(255,255,255); stop-opacity:0\" /><stop offset=\"100%\" "
200 "style=\"stop-color:rgb(0,0,255);stop-opacity:1\" /></radialGradient></defs><ellipse cx=\"200\" cy=\"70\" "
201 "rx=\"85\" ry=\"55\" fill=\"url(#grad1)\" /></svg>";
202 const std::string G_SVG_LABEL = "<svg width=\"400\" height=\"500\"> <g id=\"myId\"> </g></svg>";
203 const std::string G_ID = "myId";
204 const std::string FILTER_SVG_LABEL =
205 "<svg height=\"900\" width=\"900\"><filter id=\"composite\" y=\"0\" x=\"0\" width=\"900\" "
206 "height=\"900\"><feTurbulence baseFrequency=\".05\" numOctaves=\"3\" result=\"B\"/><feComposite in2=\"B\" "
207 "in=\"SourceGraphic\" operator=\"in\" /></filter><ellipse cx=\"100\" cy=\"87\" rx=\"75\" ry=\"87\" fill=\"red\" "
208 "filter=\"url(#composite)\"/></svg>";
209 const std::string FILTER_ID = "composite";
210 const std::string FEGAUSS_SVG_LABEL =
211 "<svg width=\"230\" height=\"120\"><filter id=\"blurMe\"><feGaussianBlur in=\"Graphic\" stdDeviation=\"5\" "
212 "/></filter><circle cx=\"170\" cy=\"60\" r=\"50\" fill=\"green\" filter=\"url(#blurMe)\" /></svg>";
213 const std::string FEGAUSS_SVG_LABEL2 =
214 "<svg width=\"-230\" height=\"-120\"><filter id=\"blurMe\"><feGaussianBlur in=\"Graphic\" stdDeviation=\"5\" "
215 "/></filter><circle cx=\"170\" cy=\"60\" r=\"50\" fill=\"green\" filter=\"url(#blurMe)\" /></svg>";
216 const std::string COMPOSITE_SVG_LABEL =
217 "<svg height=\"900\" width=\"900\"><filter id=\"composite\" y=\"0\" x=\"0\" width=\"100%\" "
218 "height=\"100%\"><feComposite in2=\"B\" "
219 "in=\"SourceGraphic\" operator=\"in\" /></filter><ellipse cx=\"100\" cy=\"87\" rx=\"75\" ry=\"87\" fill=\"red\" "
220 "filter=\"url(#composite)\"/></svg>";
221 const std::string COLOR_MATRIX_SVG_LABEL =
222 "<svg height=\"900\" width=\"900\"><filter id=\"linear\"><feColorMatrix type=\"matrix\" "
223 "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\" "
224 "rx=\"75\" ry=\"87\" fill=\"red\" filter=\"url(#linear)\"></ellipse></svg>";
225 const std::string TYPE = "matrix";
226 const std::string VALUE = "R 0 0 0 0 0 G 0 0 0 0 0 B 0 0 0 0 0 A 0";
227 const std::string ELLIPSE_SVG_LABEL1 =
228 "<svg fill=\"white\" width=\"400\" height=\"400\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><ellipse "
229 "cx=\"60\" cy=\"200\" rx=\"50\" ry=\"100\" stroke-width=\"4\" fill=\"red\" stroke=\"blue\"></ellipse></svg>";
230 const std::string ELLIPSE_SVG_LABEL2 =
231 "<svg fill=\"white\" width=\"10\" height=\"10\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><ellipse "
232 "cx=\"60\" cy=\"200\" rx=\"50\" ry=\"100\" stroke-width=\"4\" fill=\"red\" stroke=\"blue\"></ellipse></svg>";
233 const std::string ELLIPSE_SVG_LABEL3 =
234 "<svg fill=\"white\" width=\"10\" height=\"10\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><ellipse "
235 "cx=\"0.0\" cy=\"0.0\" rx=\"-1\" ry=\"-1\" stroke-width=\"4\" fill=\"red\" stroke=\"blue\"></ellipse></svg>";
236 const std::string ELLIPSE_SVG_LABEL4 =
237 "<svg fill=\"white\" width=\"10\" height=\"10\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><ellipse "
238 "cx=\"0.0\" cy=\"0.0\" rx=\"1\" ry=\"-1\" stroke-width=\"4\" fill=\"red\" stroke=\"blue\"></ellipse></svg>";
239 constexpr float ELLIPSE_CX = 60.0f;
240 constexpr float ELLIPSE_CY = 200.0f;
241 constexpr float ELLIPSE_RX = 50.0f;
242 constexpr float ELLIPSE_RY = 100.0f;
243 const std::string SVG_ANIMATE_TRANSFORM(
244 "<svg width=\"200px\" height=\"200px\" viewBox=\"0 0 100 100\" xmlns=\"http://www.w3.org/2000/svg\">"
245 "<path d =\"M50 50L20 50A30 30 0 0 0 80 50Z\">"
246 "<animateTransform attributeName =\"transform\" type=\"rotate\" repeatCount=\"3\" dur=\"1s\""
247 " values=\"0 50 50;45 50 50;0 50 50\" keyTimes=\"0;0.5;1\"></animateTransform></path></svg>");
248
249 const std::string NONE_STR = "";
250 const std::string SATURATE_VALUE = "10";
251 const std::string HUE_ROTATE = "80";
252 const std::string FE_COLOR_MATRIX =
253 "<svg width=\"900\" height=\"900\" viewBox=\"0 0 150 120\" xmlns=\"http://www.w3.org/2000/svg\">"
254 "<filter id=\"colorMatrix\">"
255 "<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\" />"
256 "<feColorMatrix type=\"saturate\" values=\"10\"/>"
257 "<feColorMatrix type=\"hueRotate\" values=\"80\"/>"
258 "<feColorMatrix type=\"luminanceToAlpha\" values=\"80\"/>"
259 "</filter>"
260 "<g>"
261 "<circle cx=\"30\" cy=\"30\" r=\"20\" fill=\"red\" fill-opacity=\"0.5\" />"
262 "</g>"
263 "<g filter=\"url(#colorMatrix)\">"
264 "<circle cx=\"80\" cy=\"30\" r=\"20\" fill=\"red\" fill-opacity=\"0.5\" />"
265 "</g>"
266 "</svg>";
267
268 const std::string FE_GAUSSIAN_BLUR =
269 "<svg width=\"900\" height=\"900\" viewBox=\"0 0 150 120\" xmlns=\"http://www.w3.org/2000/svg\">"
270 "<filter id=\"colorMatrix\">"
271 "<feGaussianBlur stdDeviation=\"10 50\"/>"
272 "<feGaussianBlur stdDeviation=\"10\"/>"
273 "<feGaussianBlur stdDeviation=\"abc abc\"/>"
274 "</filter>"
275 "<g>"
276 "<rect width=\"90\" height=\"90\" fill=\"#0099cc\" filter=\"url(#blurFilter)\" />"
277 "</g>"
278 "</svg>";
279
280 const std::string FE_FLOOD_AND_COMPOSITE =
281 "<svg width=\"900\" height=\"900\" viewBox=\"0 0 150 120\" >"
282 "<filter id=\"colorMatrix\">"
283 "<feFlood flood-color=\"red\" flood-opacity=\"0\" result=\"flood\" /><feFlood flood-color=\"green\" "
284 "flood-opacity=\"1\" result=\"flood1\" />"
285 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"xor\" result=\"composite\" k1=\"1\" "
286 "k2=\"0\"/></filter>"
287 "<g><rect width=\"90\" height=\"90\" fill=\"#0099cc\" filter=\"url(#blurFilter)\" /></g></svg>";
288
289 const std::string FE_BLEND =
290 "<svg width=\"900\" height=\"900\" viewBox=\"0 0 150 120\" xmlns=\"http://www.w3.org/2000/svg\">"
291 "<filter id=\"colorMatrix\">"
292 "<feBlend in=\"SourceGraphic\" in2=\"SourceAlpha\" mode=\"lighten\" />"
293 "</filter>"
294 "<g>"
295 "<rect width=\"90\" height=\"90\" fill=\"#0099cc\" filter=\"url(#blurFilter)\" />"
296 "</g>"
297 "</svg>";
298
299 const std::string IMAGE_HREF = "test.png";
300 const std::string IMAGE_LABEL =
301 "<svg width=\"900\" height=\"900\" viewBox=\"0 0 150 120\" xmlns=\"http://www.w3.org/2000/svg\">"
302 "<image id=\"image001\" x=\"150\" y=\"20\" width=\"100\" height=\"100\" href=\"test.png\" />"
303 "</svg>";
304
305 constexpr float IMAGE_COMPONENT_WIDTH = 100.0f;
306 constexpr float IMAGE_COMPONENT_HEIGHT = 100.0f;
307
308 std::unordered_map<std::string, std::shared_ptr<RSImageFilter>> resultHash;
309 } // namespace
310 class ParseTestTwoNg : public testing::Test {
311 public:
312 static RefPtr<SvgDom> ParseRect(const std::string& svgLabel);
313 RefPtr<SvgDom> parsePolygon(const std::string& svgLable);
314 static RefPtr<SvgDom> ParsePath(const std::string& svgLabel);
315 RefPtr<SvgDom> ParseFeGaussianblur(const std::string& svgLabel);
316 static RefPtr<SvgDom> ParseEllipse(const std::string& svgLabel);
317 void CallBack(Testing::MockCanvas& rSCanvas);
318 };
319
ParseRect(const std::string & svgLabel)320 RefPtr<SvgDom> ParseTestTwoNg::ParseRect(const std::string& svgLabel)
321 {
322 auto svgStream = SkMemoryStream::MakeCopy(RECT_SVG_LABEL.c_str(), RECT_SVG_LABEL.length());
323 EXPECT_NE(svgStream, nullptr);
324 ImageSourceInfo src;
325 src.SetFillColor(Color::BLACK);
326 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
327 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
328 EXPECT_NE(svg, nullptr);
329 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
330 auto svgRect = AceType::DynamicCast<SvgRect>(svg->children_.at(0));
331 EXPECT_NE(svgRect, nullptr);
332 auto rectDeclaration = svgRect->rectAttr_;
333 EXPECT_FLOAT_EQ(rectDeclaration.x.ConvertToPx(), X);
334 EXPECT_FLOAT_EQ(rectDeclaration.y.ConvertToPx(), Y);
335 EXPECT_FLOAT_EQ(rectDeclaration.rx.ConvertToPx(), RX);
336 EXPECT_FLOAT_EQ(rectDeclaration.ry.ConvertToPx(), RY);
337 EXPECT_FLOAT_EQ(rectDeclaration.width.ConvertToPx(), RECT_WIDTH);
338 EXPECT_FLOAT_EQ(rectDeclaration.height.ConvertToPx(), RECT_HEIGHT);
339 return svgDom;
340 }
341
parsePolygon(const std::string & svgLable)342 RefPtr<SvgDom> ParseTestTwoNg::parsePolygon(const std::string& svgLable)
343 {
344 auto svgStream = SkMemoryStream::MakeCopy(svgLable.c_str(), svgLable.length());
345 EXPECT_NE(svgStream, nullptr);
346 ImageSourceInfo src;
347 src.SetFillColor(Color::BLACK);
348 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
349 EXPECT_NE(svgDom, nullptr);
350 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
351 EXPECT_NE(svg, nullptr);
352 EXPECT_EQ(static_cast<int32_t>(svg->children_.size()), CHILD_NUMBER);
353 auto svgPolygon = AceType::DynamicCast<SvgPolygon>(svg->children_.at(0));
354 EXPECT_NE(svgPolygon, nullptr);
355 auto svgPolyline = AceType::DynamicCast<SvgPolygon>(svg->children_.at(1));
356 EXPECT_NE(svgPolyline, nullptr);
357 auto polygonDeclaration = svgPolygon->polyAttr_;
358 EXPECT_STREQ(polygonDeclaration.points.c_str(), POLYGON_POINT.c_str());
359 auto polylineDeclaration = svgPolyline->polyAttr_;
360 EXPECT_STREQ(polylineDeclaration.points.c_str(), POLYLINE_POINT.c_str());
361 return svgDom;
362 }
363
ParsePath(const std::string & svgLabel)364 RefPtr<SvgDom> ParseTestTwoNg::ParsePath(const std::string& svgLabel)
365 {
366 auto svgStream = SkMemoryStream::MakeCopy(svgLabel.c_str(), svgLabel.length());
367 EXPECT_NE(svgStream, nullptr);
368 ImageSourceInfo src;
369 src.SetFillColor(Color::BLACK);
370 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
371 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
372 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
373 auto svgPath = AceType::DynamicCast<SvgPath>(svg->children_.at(0));
374 EXPECT_NE(svgPath, nullptr);
375 auto pathDeclaration = svgPath->d_;
376 EXPECT_STREQ(pathDeclaration.c_str(), PATH_CMD.c_str());
377 return svgDom;
378 }
379
ParseFeGaussianblur(const std::string & svgLabel)380 RefPtr<SvgDom> ParseTestTwoNg::ParseFeGaussianblur(const std::string& svgLabel)
381 {
382 auto svgStream = SkMemoryStream::MakeCopy(svgLabel.c_str(), svgLabel.length());
383 EXPECT_NE(svgStream, nullptr);
384 ImageSourceInfo src;
385 src.SetFillColor(Color::BLACK);
386 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
387 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
388 EXPECT_GT(svg->children_.size(), 0);
389 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
390 EXPECT_NE(svgFilter, nullptr);
391 auto svgFeGaussiaBlur = AceType::DynamicCast<SvgFeGaussianBlur>(svgFilter->children_.at(0));
392 EXPECT_NE(svgFeGaussiaBlur, nullptr);
393 auto feDeclaration = svgFeGaussiaBlur->gaussianBlurAttr_;
394 EXPECT_EQ(feDeclaration.edgeMode, SvgFeEdgeMode::EDGE_DUPLICATE);
395 return svgDom;
396 }
397
ParseEllipse(const std::string & svgLabel)398 RefPtr<SvgDom> ParseTestTwoNg::ParseEllipse(const std::string& svgLabel)
399 {
400 auto svgStream = SkMemoryStream::MakeCopy(svgLabel.c_str(), svgLabel.length());
401 EXPECT_NE(svgStream, nullptr);
402 ImageSourceInfo src;
403 src.SetFillColor(Color::BLACK);
404 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
405 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
406 EXPECT_GT(svg->children_.size(), 0);
407 auto svgEllipse = AceType::DynamicCast<SvgEllipse>(svg->children_.at(0));
408 EXPECT_NE(svgEllipse, nullptr);
409 auto ellipseDeclaration = svgEllipse->ellipseAttr_;
410 EXPECT_FLOAT_EQ(ellipseDeclaration.cx.ConvertToPx(), ELLIPSE_CX);
411 EXPECT_FLOAT_EQ(ellipseDeclaration.cy.ConvertToPx(), ELLIPSE_CY);
412 EXPECT_FLOAT_EQ(ellipseDeclaration.rx.ConvertToPx(), ELLIPSE_RX);
413 EXPECT_FLOAT_EQ(ellipseDeclaration.ry.ConvertToPx(), ELLIPSE_RY);
414 return svgDom;
415 }
416
CallBack(Testing::MockCanvas & rSCanvas)417 void ParseTestTwoNg::CallBack(Testing::MockCanvas& rSCanvas)
418 {
419 EXPECT_CALL(rSCanvas, AttachBrush(_)).WillRepeatedly(ReturnRef(rSCanvas));
420 EXPECT_CALL(rSCanvas, DetachBrush()).WillRepeatedly(ReturnRef(rSCanvas));
421 EXPECT_CALL(rSCanvas, AttachPen(_)).WillRepeatedly(ReturnRef(rSCanvas));
422 EXPECT_CALL(rSCanvas, DetachPen()).WillRepeatedly(ReturnRef(rSCanvas));
423 EXPECT_CALL(rSCanvas, DrawPath(_)).Times(AtLeast(1));
424 }
425
426 /**
427 * @tc.name: ParseLineTest002
428 * @tc.desc: Create an SvgLine and set path
429 * @tc.type: FUNC
430 */
431 HWTEST_F(ParseTestTwoNg, ParseLineTest002, TestSize.Level1)
432 {
433 /* *
434 * @tc.steps: step1. call AsPath
435 * @tc.expected: Execute function return value not is nullptr
436 */
437 auto svgLine = AccessibilityManager::MakeRefPtr<SvgLine>();
438 svgLine->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
439 EXPECT_NE(svgLine, nullptr);
440 }
441
442 /**
443 * @tc.name: ParseEllipseTest005
444 * @tc.desc: Create an SvgEllipse and set path
445 * @tc.type: FUNC
446 */
447 HWTEST_F(ParseTestTwoNg, ParseEllipseTest005, TestSize.Level1)
448 {
449 auto svgStream = SkMemoryStream::MakeCopy(ELLIPSE_SVG_LABEL3.c_str(), ELLIPSE_SVG_LABEL3.length());
450 EXPECT_NE(svgStream, nullptr);
451
452 /* *
453 * @tc.steps: step1. call CreateSvgDom
454 * @tc.expected: Execute function return value size not is 0
455 */
456 ImageSourceInfo src;
457 src.SetFillColor(Color::BLACK);
458 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
459 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
460 EXPECT_GT(svg->children_.size(), 0);
461
462 /* *
463 * @tc.steps: step2. call AsPath
464 * @tc.expected: Execute function return value not is nullptr
465 */
466 auto svgEllipse = AceType::DynamicCast<SvgEllipse>(svg->children_.at(0));
467 svgEllipse->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
468 EXPECT_NE(svgEllipse, nullptr);
469 }
470
471 /**
472 * @tc.name: ParseEllipseTest006
473 * @tc.desc: Create an SvgEllipse and set patha
474 * @tc.type: FUNC
475 */
476 HWTEST_F(ParseTestTwoNg, ParseEllipseTest006, TestSize.Level1)
477 {
478 auto svgStream = SkMemoryStream::MakeCopy(ELLIPSE_SVG_LABEL4.c_str(), ELLIPSE_SVG_LABEL4.length());
479 EXPECT_NE(svgStream, nullptr);
480
481 /* *
482 * @tc.steps: step1. call CreateSvgDom
483 * @tc.expected: Execute function return value size not is 0
484 */
485 ImageSourceInfo src;
486 src.SetFillColor(Color::BLACK);
487 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
488 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
489 EXPECT_GT(svg->children_.size(), 0);
490
491 /* *
492 * @tc.steps: step2. call AsPath
493 * @tc.expected: Execute function return value not is nullptr
494 */
495 auto svgEllipse = AceType::DynamicCast<SvgEllipse>(svg->children_.at(0));
496 svgEllipse->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
497 EXPECT_NE(svgEllipse, nullptr);
498 }
499
500 /**
501 * @tc.name: ParsePolygonTest003
502 * @tc.desc: parse polygon and polyline label
503 * @tc.type: FUNC
504 */
505 HWTEST_F(ParseTestTwoNg, ParsePolygonTest003, TestSize.Level1)
506 {
507 /* *
508 * @tc.steps: step1. call CreateSvgDom
509 * @tc.expected: Execute svgDom root node is 2
510 */
511 auto svgStream = SkMemoryStream::MakeCopy(POLYGON_SVG_LABEL1.c_str(), POLYGON_SVG_LABEL1.length());
512 ImageSourceInfo src;
513 src.SetFillColor(Color::BLACK);
514 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
515 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
516 EXPECT_EQ(static_cast<int32_t>(svg->children_.size()), CHILD_NUMBER);
517
518 /* *
519 * @tc.steps: step2. call AsPath
520 * @tc.expected: Execute SvgPolygon Points is empty
521 */
522 auto svgPolygon = AceType::DynamicCast<SvgPolygon>(svg->children_.at(0));
523 auto declaration = svgPolygon->polyAttr_;
524 declaration.points = "";
525 svgPolygon->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
526 EXPECT_TRUE(declaration.points.empty());
527
528 /* *
529 * @tc.steps: step3. call AsPath
530 * @tc.expected: Execute SvgPolygon Points parse error
531 */
532 declaration.points = "ccc";
533 svgPolygon->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
534 EXPECT_FALSE(declaration.points.empty());
535 }
536
537 /**
538 * @tc.name: ParseStyleTest002
539 * @tc.desc: parse use label
540 * @tc.type: FUNC
541 */
542 HWTEST_F(ParseTestTwoNg, ParseStyleTest002, TestSize.Level1)
543 {
544 /* *
545 * @tc.steps: step1. call ParseCssStyle
546 * @tc.expected: Execute function return value false
547 */
548 SvgStyle::ParseCssStyle("", nullptr);
549 std::string str;
__anon568f58b60202(const std::string& key, const std::pair<std::string, std::string>& value) 550 PushAttr callback = [&str](const std::string& key, const std::pair<std::string, std::string>& value) { str = key; };
551 SvgStyle::ParseCssStyle("body {font-style: oblique;}.normal {font-style: normal;}", callback);
552 EXPECT_FALSE(str.empty());
553
554 SvgStyle::ParseCssStyle("body font-style: oblique;}. {font-style: normal;}", callback);
555 EXPECT_FALSE(str.empty());
556 }
557
558 /**
559 * @tc.name: ParseRectTest004
560 * @tc.desc: parse rect label
561 * @tc.type: FUNC
562 */
563 HWTEST_F(ParseTestTwoNg, ParseRectTest004, TestSize.Level1)
564 {
565 auto svgStream = SkMemoryStream::MakeCopy(RECT_SVG_LABEL3.c_str(), RECT_SVG_LABEL3.length());
566 ImageSourceInfo src;
567 src.SetFillColor(Color::BLACK);
568 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
569 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
570 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
571
572 /* *
573 * @tc.steps: step1. call AsPath
574 * @tc.expected: Execute function return value not is 0
575 */
576 auto svgRect = AceType::DynamicCast<SvgRect>(svg->children_.at(0));
577 svgRect->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
578 auto rectDeclaration = svgRect->rectAttr_;
579 EXPECT_NE(rectDeclaration.rx.Value(), 0);
580 }
581
582 /**
583 * @tc.name: ParseUseTest002
584 * @tc.desc: parse use label
585 * @tc.type: FUNC
586 */
587 HWTEST_F(ParseTestTwoNg, ParseUseTest002, TestSize.Level1)
588 {
589 auto svgStream = SkMemoryStream::MakeCopy(USE_SVG_LABEL.c_str(), USE_SVG_LABEL.length());
590 ImageSourceInfo src;
591 src.SetFillColor(Color::GREEN);
592 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
593 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
594 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
595
596 /* *
597 * @tc.steps: step1. call AsPath
598 * @tc.expected: Execute function return value is true
599 */
600 auto svgUse = AceType::DynamicCast<SvgUse>(svg->children_.at(INDEX_ONE));
601 svgUse->attributes_.href = "";
602 svgUse->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
603 EXPECT_TRUE(svgUse->attributes_.href.empty());
604 }
605
606 /**
607 * @tc.name: ParseImageTest001
608 * @tc.desc: parse image label
609 * @tc.type: FUNC
610 */
611 HWTEST_F(ParseTestTwoNg, ParseImageTest001, TestSize.Level1)
612 {
613 auto svgStream = SkMemoryStream::MakeCopy(IMAGE_LABEL.c_str(), IMAGE_LABEL.length());
614 ImageSourceInfo src;
615 src.SetFillColor(Color::BLACK);
616 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
617 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
618 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
619
620 /* *
621 * @tc.steps: step1. call AsPath
622 * @tc.expected: Execute function return value is true
623 */
624 auto svgImage = AceType::DynamicCast<SvgImage>(svg->children_.at(0));
625 auto imageDeclaration = svgImage->imageAttr_;
626 EXPECT_FLOAT_EQ(imageDeclaration.x.ConvertToPx(), X);
627 EXPECT_FLOAT_EQ(imageDeclaration.y.ConvertToPx(), Y);
628 EXPECT_FLOAT_EQ(imageDeclaration.width.ConvertToPx(), RECT_WIDTH);
629 EXPECT_FLOAT_EQ(imageDeclaration.height.ConvertToPx(), RECT_HEIGHT);
630 EXPECT_STREQ(imageDeclaration.href.c_str(), IMAGE_HREF.c_str());
631 }
632
633 /**
634 * @tc.name: ParseGradientTest001
635 * @tc.desc: parse Gradient set
636 * @tc.type: FUNC
637 */
638 HWTEST_F(ParseTestTwoNg, ParseGradientTest001, TestSize.Level1)
639 {
640 auto svgStream = SkMemoryStream::MakeCopy(CIRCLE_SVG_LABEL.c_str(), CIRCLE_SVG_LABEL.length());
641 EXPECT_NE(svgStream, nullptr);
642 ImageSourceInfo src;
643 src.SetFillColor(Color::BLACK);
644 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
645 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
646 EXPECT_GT(svg->children_.size(), 0);
647 auto svgCircle = AceType::DynamicCast<SvgCircle>(svg->children_.at(0));
648 EXPECT_NE(svgCircle, nullptr);
649
650 Gradient gradient;
651 LinearGradient linearGradientLocal;
652 linearGradientLocal.x1 = Dimension(1.0);
653 linearGradientLocal.x2 = Dimension(1.0);
654 linearGradientLocal.y1 = Dimension(1.0);
655 linearGradientLocal.y2 = Dimension(1.0);
656 gradient.SetLinearGradient(linearGradientLocal);
657 svgCircle->SetLinearGradient(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), gradient);
658 auto linearGradientInfo = gradient.GetLinearGradientInfo();
659 EXPECT_NE(linearGradientInfo.x1, 0.0);
660 linearGradientLocal.x1 = Dimension(1.0, DimensionUnit::PERCENT);
661 linearGradientLocal.x2 = Dimension(1.0, DimensionUnit::PERCENT);
662 linearGradientLocal.y1 = Dimension(1.0, DimensionUnit::PERCENT);
663 linearGradientLocal.y2 = Dimension(1.0, DimensionUnit::PERCENT);
664 gradient.SetLinearGradient(linearGradientLocal);
665 svgCircle->SetLinearGradient(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), gradient);
666 linearGradientInfo = gradient.GetLinearGradientInfo();
667 EXPECT_EQ(linearGradientInfo.x1, 0.0);
668
669 RadialGradient radialGradientLocal;
670 radialGradientLocal.radialHorizontalSize = AnimatableDimension(1);
671 radialGradientLocal.radialCenterX = AnimatableDimension(1);
672 radialGradientLocal.radialCenterY = AnimatableDimension(1);
673 radialGradientLocal.fRadialCenterX = Dimension(1);
674 radialGradientLocal.fRadialCenterY = Dimension(1);
675 gradient.SetRadialGradient(radialGradientLocal);
676 auto radialGradientInfo = gradient.GetRadialGradientInfo();
677 EXPECT_EQ(radialGradientInfo.r, 0.0);
678 EXPECT_EQ(radialGradientInfo.cx, 0.0);
679 EXPECT_EQ(radialGradientInfo.cy, 0.0);
680 EXPECT_EQ(radialGradientInfo.fx, 0.0);
681 EXPECT_EQ(radialGradientInfo.fy, 0.0);
682 svgCircle->SetRadialGradient(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), gradient);
683 radialGradientInfo = gradient.GetRadialGradientInfo();
684 EXPECT_NE(radialGradientInfo.r, 0.0);
685 EXPECT_NE(radialGradientInfo.cx, 0.0);
686 EXPECT_NE(radialGradientInfo.cy, 0.0);
687 EXPECT_NE(radialGradientInfo.fx, 0.0);
688 EXPECT_NE(radialGradientInfo.fy, 0.0);
689 }
690
691 /**
692 * @tc.name: ParseGradientTest002
693 * @tc.desc: parse Gradient set
694 * @tc.type: FUNC
695 */
696 HWTEST_F(ParseTestTwoNg, ParseGradientTest002, TestSize.Level1)
697 {
__anon568f58b60302(Gradient &gradient) 698 std::function func = [&](Gradient &gradient) {
699 auto svgStream = SkMemoryStream::MakeCopy(CIRCLE_SVG_LABEL.c_str(), CIRCLE_SVG_LABEL.length());
700 EXPECT_NE(svgStream, nullptr);
701 ImageSourceInfo src;
702 src.SetFillColor(Color::BLACK);
703 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
704 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
705 auto svgCircle = AceType::DynamicCast<SvgCircle>(svg->children_.at(0));
706 EXPECT_NE(svgCircle, nullptr);
707
708 auto viewPort = Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT);
709 auto baseAttr = svgCircle->GetBaseAttributes();
710 gradient.SetType(GradientType::LINEAR);
711 svgCircle->fillState_.SetGradient(gradient);
712 baseAttr.fillState.SetGradient(gradient);
713 baseAttr.strokeState.SetGradient(gradient);
714 svgCircle->SetBaseAttributes(baseAttr);
715 svgCircle->SetGradientStyle(0);
716 svgCircle->SetStrokeGradientStyle(0);
717 svgCircle->UpdateFillGradient(viewPort);
718 svgCircle->UpdateStrokeGradient(viewPort);
719
720 RadialGradient radialGradientLocal;
721 radialGradientLocal.radialHorizontalSize = AnimatableDimension(1);
722 radialGradientLocal.radialCenterX = AnimatableDimension(1);
723 radialGradientLocal.radialCenterY = AnimatableDimension(1);
724 radialGradientLocal.fRadialCenterX = Dimension(1);
725 radialGradientLocal.fRadialCenterY = Dimension(1);
726 gradient.SetRadialGradient(radialGradientLocal);
727 gradient.SetType(GradientType::RADIAL);
728 svgCircle->fillState_.SetGradient(gradient);
729 baseAttr.fillState.SetGradient(gradient);
730 baseAttr.strokeState.SetGradient(gradient);
731 svgCircle->SetBaseAttributes(baseAttr);
732 svgCircle->SetGradientStyle(1);
733 svgCircle->SetStrokeGradientStyle(1);
734 svgCircle->UpdateFillGradient(viewPort);
735 svgCircle->UpdateStrokeGradient(viewPort);
736 };
737 Gradient gradient;
738 func(gradient);
739 gradient.AddColor(GradientColor(Color::RED));
740 func(gradient);
741 }
742
743 /**
744 * @tc.name: ParseNodeTest001
745 * @tc.desc: SvgNode SetAttr Parameters
746 * @tc.type: FUNC
747 */
748 HWTEST_F(ParseTestTwoNg, ParseNodeTest001, TestSize.Level1)
749 {
750 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
751 svgNode->SetAttr("stroke-dasharray", "");
752
753 svgNode->SetAttr("stroke-linecap", "round");
754 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineCap(), LineCapStyle::ROUND);
755
756 svgNode->SetAttr("strokeLinecap", "square");
757 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineCap(), LineCapStyle::SQUARE);
758
759 svgNode->SetAttr("stroke-linejoin", "bevel");
760 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineJoin(), LineJoinStyle::BEVEL);
761
762 svgNode->SetAttr("strokeLinejoin", "round");
763 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineJoin(), LineJoinStyle::ROUND);
764
765 svgNode->SetAttr("stroke-miterlimit", "0.1");
766 EXPECT_NE(svgNode->GetBaseAttributes().strokeState.GetMiterLimit(), 0.1);
767
768 svgNode->SetAttr("stroke-miterlimit", "1.1");
769 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetMiterLimit(), 1.1);
770
771 svgNode->SetAttr("strokeMiterlimit", "0.2");
772 EXPECT_NE(svgNode->GetBaseAttributes().strokeState.GetMiterLimit(), 0.2);
773
774 svgNode->SetAttr("strokeMiterlimit", "1.2");
775 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetMiterLimit(), 1.2);
776
777 svgNode->SetAttr("strokeOpacity", "0.321");
778 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetOpacity().GetValue(), 0.321);
779
780 svgNode->SetAttr("strokeWidth", "1.2");
781 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineWidth().Value(), 1.2);
782
783 svgNode->SetAttr("strokeWidth", "-1.2");
784 EXPECT_NE(svgNode->GetBaseAttributes().strokeState.GetLineWidth().Value(), -1.2);
785
786 svgNode->SetAttr("stroke-width", "-1.2");
787 EXPECT_NE(svgNode->GetBaseAttributes().strokeState.GetLineWidth().Value(), -1.2);
788
789 svgNode->SetAttr("strokeDasharray", "");
790 svgNode->SetAttr("strokeDasharray", "1.1 1.2");
791 auto tesData = std::vector{1.1, 1.2};
792 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineDash().lineDash, tesData);
793
794 svgNode->SetAttr("strokeDashoffset", "2.0");
795 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineDash().dashOffset, 2.0);
796
797 svgNode->SetAttr("transform-origin", "test_transform-origin");
798 EXPECT_EQ(svgNode->GetBaseAttributes().transformOrigin, "test_transform-origin");
799
800 svgNode->SetAttr("xlink:href", "test_xlink:href");
801 EXPECT_NE(svgNode->GetBaseAttributes().href, "test_xlink:href");
802 }
803
804 /**
805 * @tc.name: ParseNodeTest002
806 * @tc.desc: SvgNode test
807 * @tc.type: FUNC
808 */
809 HWTEST_F(ParseTestTwoNg, ParseNodeTest002, TestSize.Level1)
810 {
811 auto svgStream = SkMemoryStream::MakeCopy(SVG_ANIMATE_TRANSFORM.c_str(), SVG_ANIMATE_TRANSFORM.length());
812 ImageSourceInfo src;
813 Size size;
814 src.SetFillColor(Color::GREEN);
815 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
816 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
817
818 Testing::MockCanvas rSCanvas;
819 CallBack(rSCanvas);
820 svgDom->root_->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
821 svg->OnFilter(rSCanvas, size);
822
823 auto containerSize = svgDom->GetContainerSize();
824 EXPECT_EQ(containerSize, SizeF(200.0f, 200.0f));
825
826 svgDom->SetFillColor(Color::RED);
827 EXPECT_EQ(svgDom->fillColor_.value(), Color::RED);
828
829 svgDom->SetSmoothEdge(1.1f);
830 EXPECT_EQ(svgDom->smoothEdge_, 1.1f);
831
832 svgDom->ControlAnimation(true);
833 EXPECT_EQ(svg->GetGradient(string("")), std::nullopt);
834 }
835
836 /**
837 * @tc.name: ParseNodeTest003
838 * @tc.desc: SvgNode test
839 * @tc.type: FUNC
840 */
841 HWTEST_F(ParseTestTwoNg, ParseNodeTest003, TestSize.Level1)
842 {
843 Size size;
844 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
845 auto dimension = Dimension(0.0, DimensionUnit::PERCENT);
846
847 SvgLengthType svgLengthType = static_cast<SvgLengthType>(int(SvgLengthType::OTHER)+1);
848 EXPECT_EQ(svgNode->ConvertDimensionToPx(dimension, size, svgLengthType), 0.0);
849 dimension.SetUnit(DimensionUnit::AUTO);
850 EXPECT_EQ(svgNode->ConvertDimensionToPx(dimension, size, svgLengthType), 0.0);
851
852 EXPECT_EQ(svgNode->ConvertDimensionToPx(dimension, 1.0), 0.0);
853
854 EXPECT_EQ(svgNode->GetRootViewBox(), Rect());
855 }
856
857 /**
858 * @tc.name: SvgGraphicTest001
859 * @tc.desc: SvgGraphic test
860 * @tc.type: FUNC
861 */
862 HWTEST_F(ParseTestTwoNg, SvgGraphicTest001, TestSize.Level1)
863 {
864 auto svgStream = SkMemoryStream::MakeCopy(CIRCLE_SVG_LABEL.c_str(), CIRCLE_SVG_LABEL.length());
865 EXPECT_NE(svgStream, nullptr);
866 ImageSourceInfo src;
867 src.SetFillColor(Color::BLACK);
868 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
869 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
870 auto svgCircle = AceType::DynamicCast<SvgCircle>(svg->children_.at(0));
871 EXPECT_NE(svgCircle, nullptr);
872 auto svgAnimateStream = SkMemoryStream::MakeCopy(SVG_ANIMATE_TRANSFORM.c_str(), SVG_ANIMATE_TRANSFORM.length());
873 ImageSourceInfo svgAnimate;
874 src.SetFillColor(Color::GREEN);
875 auto svgAnimateDom = SvgDom::CreateSvgDom(*svgAnimateStream, src);
876 auto svgAnimateNode = svgAnimateDom->root_;
877 Testing::MockCanvas rSCanvas;
878
879 std::string href = "svgNodeTest";
880 auto baseAttr = svgCircle->GetBaseAttributes();
881 baseAttr.fillState.SetHref(href);
882 svgCircle->SetBaseAttributes(baseAttr);
883 auto svgContext = svgCircle->svgContext_.Upgrade();
884 svgContext->Push(href, svgAnimateNode);
885
886 Gradient gradient;
887 ImageColorFilter imageColorFilter;
888 std::vector<float> values = {255.0f, 0.0f, 0.0f};
889 auto colorFilterMatrix = std::make_shared<std::vector<float>>(values);
890 auto colorFilterDrawing = DrawingColorFilter::CreateDrawingColorFilter(values);
891 svgCircle->SetColorFilter(imageColorFilter);
892
893 imageColorFilter.colorFilterDrawing_ = colorFilterDrawing;
894 svgCircle->SetColorFilter(imageColorFilter);
895 baseAttr.strokeState.SetLineCap(LineCapStyle::BUTT);
896 baseAttr.strokeState.SetLineJoin(LineJoinStyle::MITER);
897 svgCircle->SetBaseAttributes(baseAttr);
898 EXPECT_EQ(svgCircle->UpdateStrokeStyle(true), true);
899
900 imageColorFilter.colorFilterMatrix_ = colorFilterMatrix;
901 svgCircle->SetColorFilter(imageColorFilter);
902 baseAttr.strokeState.SetLineCap(LineCapStyle::ROUND);
903 baseAttr.strokeState.SetLineJoin(LineJoinStyle::ROUND);
904 svgCircle->SetBaseAttributes(baseAttr);
905 EXPECT_EQ(svgCircle->UpdateStrokeStyle(true), true);
906
907 baseAttr.strokeState.SetLineCap(LineCapStyle::SQUARE);
908 baseAttr.strokeState.SetLineJoin(LineJoinStyle::BEVEL);
909 svgCircle->SetBaseAttributes(baseAttr);
910 EXPECT_EQ(svgCircle->UpdateStrokeStyle(true), true);
911 }
912
913 /**
914 * @tc.name: SvgDomTest001
915 * @tc.desc: SvgDom test
916 * @tc.type: FUNC
917 */
918 HWTEST_F(ParseTestTwoNg, SvgDomTest001, TestSize.Level1)
919 {
920 ImageSourceInfo src;
921 auto size = Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT);
922 auto svgAnimateStream = SkMemoryStream::MakeCopy(SVG_ANIMATE_TRANSFORM.c_str(), SVG_ANIMATE_TRANSFORM.length());
923 src.SetFillColor(Color::GREEN);
924 auto svgAnimateDom = SvgDom::CreateSvgDom(*svgAnimateStream, src);
925
926 Testing::MockCanvas rSCanvas;
927 CallBack(rSCanvas);
928 EXPECT_EQ(svgAnimateDom->layout_, Size(0.0, 0.0));
929 svgAnimateDom->DrawImage(rSCanvas, ImageFit::COVER, size);
930 EXPECT_EQ(svgAnimateDom->layout_, size);
931
932 ImageColorFilter imageColorFilter;
933 svgAnimateDom->SetColorFilter(imageColorFilter);
934 EXPECT_EQ(svgAnimateDom->colorFilter_->colorFilterDrawing_, nullptr);
935 EXPECT_EQ(svgAnimateDom->colorFilter_->colorFilterMatrix_, nullptr);
936 }
937 } // namespace OHOS::Ace::NG
938