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_transform.h"
76 #include "core/components_ng/svg/parse/svg_use.h"
77 #include "core/components_ng/svg/svg_dom.h"
78
79 using namespace testing;
80 using namespace testing::ext;
81 namespace OHOS::Ace::NG {
82 namespace {
83 const std::string CIRCLE_SVG_LABEL =
84 "<svg width=\"400px\" height=\"400px\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><circle cx=\"60px\" "
85 "cy=\"200px\" r = \"50px\" fill=\"red\" opacity=\"0.5\" stroke=\"blue\" stroke-width=\"16px\" "
86 "stroke-opacity=\"0.3\" id=\"circleId\"/></svg>";
87 const std::string CLIP_SVG_LABEL =
88 "<svg width=\"120\" height=\"120\" viewBox=\"0 0 120 120\" version=\"1.1\"><defs><clipPath id=\"myClip\"><circle "
89 "cx=\"30\" cy=\"30\" r=\"20\"/><circle cx=\"70\" cy=\"70\" r=\"30\"/></clipPath></defs><rect x=\"10\" y=\"10\" "
90 "width=\"100\" height=\"100\" clip-path=\"url(#myClip)\" fill=\"red\" /></svg>";
91 const std::string ID = "myClip";
92 const std::string SVG_LABEL = "<svg width=\"400\" height=\"500\" viewBox=\"-4 -10 300 300\"></svg>";
93 const std::string USE_SVG_LABEL =
94 "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"24\" height=\"24\" "
95 "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 "
96 "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 "
97 "10.2573593,13.5 11.5,13.5 Z M11.5006868,9 C13.6153489,9 15.5906493,9.84916677 16.9758057,11.3106505 "
98 "C17.3557222,11.7115019 17.3387512,12.3444394 16.9378998,12.724356 C16.5370484,13.1042725 15.9041109,13.0873015 "
99 "15.5241943,12.6864501 C14.5167672,11.62351 13.0663814,11 11.5006868,11 C9.93437756,11 8.48347933,11.6240033 "
100 "7.47603048,12.6876625 C7.09624495,13.0886381 6.46331303,13.105816 6.06233747,12.7260305 C5.66136192,12.3462449 "
101 "5.644184,11.713313 6.02396952,11.3123375 C7.40917586,9.84984392 9.38518621,9 11.5006868,9 Z M11.5002692,4.5 "
102 "C14.7685386,4.5 17.818619,5.90678629 19.9943022,8.33155689 C20.3631417,8.74262367 20.3289097,9.37486259 "
103 "19.9178429,9.74370206 C19.5067762,10.1125415 18.8745372,10.0783095 18.5056978,9.66724276 C16.703513,7.6587313 "
104 "14.1912454,6.5 11.5002692,6.5 C8.80904291,6.5 6.29656204,7.6589485 4.49435171,9.66778779 C4.1255427,10.0788819 "
105 "3.49330631,10.1131607 3.08221221,9.74435171 C2.67111811,9.3755427 2.63683928,8.74330631 3.00564829,8.33221221 "
106 "C5.1813597,5.90704879 8.23169642,4.5 11.5002692,4.5 Z M11.4995363,-5.68434189e-14 C15.8001105,-5.68434189e-14 "
107 "19.8214916,1.76017363 22.7244081,4.81062864 C23.1051374,5.21070819 23.0894509,5.84367883 22.6893714,6.22440812 "
108 "C22.2892918,6.60513741 21.6563212,6.58945092 21.2755919,6.18937136 C18.7465254,3.53176711 15.2469734,2 "
109 "11.4995363,2 C7.75253773,2 4.25335915,3.53140612 1.72434435,6.1884639 C1.34357805,6.58850824 "
110 "0.71060597,6.60413618 0.310561632,6.22336988 C-0.0894827058,5.84260359 -0.105110646,5.2096315 "
111 "0.27565565,4.80958716 C3.1785132,1.75975912 7.19946582,-5.68434189e-14 11.4995363,-5.68434189e-14 "
112 "Z\"/></defs><use fill=\"red\" fill-rule=\"nonzero\" stroke=\"blue\" stroke-width=\"1\" "
113 "transform=\"translate(.5 2.75)\" xlink:href=\"#uxs-a\"/></svg>";
114 const std::string HREF = "uxs-a";
115 const std::string FILL_RULE = "nonzero";
116 const std::string TRANSFORM = "translate(.5 2.75)";
117 constexpr int32_t INDEX_ONE = 1;
118 const std::string STYLE_SVG_LABEL = "<svg viewBox=\"0 0 10 10\"><style>circle{fill:gold;stroke:maroon;stroke-width : "
119 "2px;}</style><circle cx =\"5\" cy=\"5\" r=\"4\" /></svg>";
120 const std::string STOP_SVG_LABEL =
121 "<svg height=\"150\" width=\"400\"><defs><linearGradient id=\"grad1\" x1=\"0%\" y1=\"0%\" x2=\"100%\" "
122 "y2=\"0%\"><stop offset=\"0%\" style=\"stop-color:rgb(255,255,0);stop-opacity:1\" /><stop offset=\"20px\" "
123 "style=\"stop-color:rgb(255,0,0);stop-opacity:1\" /></linearGradient></defs><ellipse cx=\"200\" cy=\"70\" "
124 "rx=\"85\" ry=\"55\" fill=\"url(#grad1)\" /></svg>";
125 constexpr int32_t CHILD_NUMBER = 2;
126 const std::string RECT_SVG_LABEL = "<svg width=\"400\" height=\"400\" 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_LABEL2 = "<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=\"10\" ry=\"10\"></rect></svg>";
132 const std::string RECT_SVG_LABEL3 = "<svg version=\"1.1\" fill=\"red\" "
133 "xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"100\" height=\"100\" x=\"150\" "
134 "y=\"20\" stroke-width=\"4\" stroke=\"#000000\" rx=\"1\" ry=\"-1\"></rect></svg>";
135 const std::string RECT_SVG_LABEL4 = "<svg version=\"1.1\" fill=\"red\" "
136 "xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"100\" height=\"100\" x=\"150\" "
137 "y=\"20\" stroke-width=\"4\" stroke=\"#000000\" rx=\"-1\" ry=\"1\"></rect></svg>";
138 constexpr float X = 150.0f;
139 constexpr float Y = 20.0f;
140 constexpr float RX = 10.0f;
141 constexpr float RY = 10.0f;
142 constexpr float RECT_WIDTH = 100.0f;
143 constexpr float RECT_HEIGHT = 100.0f;
144 const std::string POLYGON_SVG_LABEL1 =
145 "<svg fill=\"white\" stroke=\"blue\" width=\"800\" height=\"400\" version=\"1.1\" "
146 "xmlns=\"http://www.w3.org/2000/svg\"><polygon points=\"10,110 60,35 60,85 110,10\" "
147 "fill=\"red\"></polygon> <polyline points=\"10,200 60,125 60,175 110,100\" "
148 "stroke-dasharray=\"10 5\" stroke-dashoffset=\"3\"></polyline></svg>";
149 const std::string POLYGON_SVG_LABEL2 =
150 "<svg fill=\"white\" stroke=\"blue\" width=\"300\" height=\"400\" version=\"1.1\" "
151 "xmlns=\"http://www.w3.org/2000/svg\"><polygon points=\"10,110 60,35 60,85 110,10\" "
152 "fill=\"red\"></polygon> <polyline points=\"10,200 60,125 60,175 110,100\" "
153 "stroke-dasharray=\"10 5\" stroke-dashoffset=\"3\"></polyline></svg>";
154 const std::string POLYGON_POINT = "10,110 60,35 60,85 110,10";
155 const std::string POLYLINE_POINT = "10,200 60,125 60,175 110,100";
156 const std::string PATTERN_SVG_LABEL =
157 "<svg viewBox=\"0 0 230 100\"><defs><pattern id=\"star\" viewBox=\"0 0 10 10\" width=\"10\" "
158 "height=\"10\"><polygon points=\"0,0 2,5 0,10 5,8 10,10 8,5 10,0 5,2\" /></pattern></defs><circle cx=\"50\" "
159 "cy=\"50\" r=\"50\" fill=\"url(#star)\" /><circle cx=\"180\" cy=\"50\" r=\"40\" fill=\"none\" stroke-width=\"20\" "
160 "stroke=\"url(#star)\"/> </svg>";
161 const std::string PATH_SVG_LABEL1 =
162 "<svg width=\"400\" height=\"800\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M 10,30 A 20,20 "
163 "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\" "
164 "fill=\"red\"></path></svg>";
165 const std::string PATH_SVG_LABEL2 =
166 "<svg version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M 10,30 A 20,20 "
167 "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\" "
168 "fill=\"red\"></path></svg>";
169 const std::string PATH_SVG_LABEL3 =
170 "<svg width=\"-400\" height=\"-400\" viewBox=\"-4 -10 300 300\" version=\"1.1\" "
171 "xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M 10,30 A 20,20 "
172 "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\" "
173 "fill=\"red\"></path></svg>";
174 const std::string PATH_SVG_LABEL4 =
175 "<svg width=\"300\" height=\"400\" viewBox=\"-4 -10 300 300\" version=\"1.1\" "
176 "xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M 10,30 A 20,20 "
177 "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\" "
178 "fill=\"red\"></path></svg>";
179 const std::string PATH_SVG_LABEL5 =
180 "<svg width=\"400\" height=\"400\" viewBox=\"-4 -10 -300 -300\" version=\"1.1\" "
181 "xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M 10,30 A 20,20 "
182 "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\" "
183 "fill=\"red\"></path></svg>";
184 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";
185 const std::string MASK_SVG_LABEL =
186 "<svg width=\"50px\" height=\"50px\" viewBox=\"0 0 24 24\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" "
187 "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 "
188 "-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 "
189 "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 "
190 "-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\" "
191 "stroke-width=\"1\" fill=\"none\" fill-rule=\"evenodd\"><g><mask id=\"mask-2\" fill=\"#FFFFFF\"><use "
192 "xlink:href=\"#path-1\"></use></mask><use id=\"myId\" fill=\"#FFFFFF\" fill-rule=\"nonzero\" "
193 "xlink:href=\"#path-1\"></use></g></g></svg>";
194 const std::string MASK_ID = "mask-2";
195 const std::string LINE_SVG_LABEL =
196 "<svg width=\"400\" height=\"400\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><line x1=\"10\" x2=\"300\" "
197 "y1=\"50\" y2=\"50\" stroke-width=\"4\" fill=\"white\" stroke=\"blue\"></line></svg>";
198 const std::string GRADIENT_SVG_LINEAR =
199 "<svg height=\"150\" width=\"400\"><defs><linearGradient id=\"grad1\" x1=\"0%\" y1=\"0%\" x2=\"100%\" "
200 "y2=\"0%\"><stop offset=\"0%\" style=\"stop-color:rgb(255,255,0);stop-opacity:1\" /><stop offset=\"100%\" "
201 "style=\"stop-color:rgb(255,0,0);stop-opacity:1\" /></linearGradient></defs><ellipse cx=\"200\" cy=\"70\" "
202 "rx=\"85\" ry=\"55\" fill=\"url(#grad1)\" /></svg>";
203 const std::string GRADIENT_SVG_RADIAL =
204 "<svg height=\"150\" width=\"500\"><defs><radialGradient id=\"grad1\" cx=\"50%\" cy=\"50%\" r=\"50%\" fx=\"50%\" "
205 "fy=\"50%\"><stop offset=\"0%\" style=\"stop-color:rgb(255,255,255); stop-opacity:0\" /><stop offset=\"100%\" "
206 "style=\"stop-color:rgb(0,0,255);stop-opacity:1\" /></radialGradient></defs><ellipse cx=\"200\" cy=\"70\" "
207 "rx=\"85\" ry=\"55\" fill=\"url(#grad1)\" /></svg>";
208 const std::string G_SVG_LABEL = "<svg width=\"400\" height=\"500\"> <g id=\"myId\"> </g></svg>";
209 const std::string G_ID = "myId";
210 const std::string FILTER_SVG_LABEL =
211 "<svg height=\"900\" width=\"900\"><filter id=\"composite\" y=\"0\" x=\"0\" width=\"900\" "
212 "height=\"900\"><feTurbulence baseFrequency=\".05\" numOctaves=\"3\" result=\"B\"/><feComposite in2=\"B\" "
213 "in=\"SourceGraphic\" operator=\"in\" /></filter><ellipse cx=\"100\" cy=\"87\" rx=\"75\" ry=\"87\" fill=\"red\" "
214 "filter=\"url(#composite)\"/></svg>";
215 const std::string FILTER_ID = "composite";
216 const std::string FEGAUSS_SVG_LABEL =
217 "<svg width=\"230\" height=\"120\"><filter id=\"blurMe\"><feGaussianBlur in=\"Graphic\" stdDeviation=\"5\" "
218 "/></filter><circle cx=\"170\" cy=\"60\" r=\"50\" fill=\"green\" filter=\"url(#blurMe)\" /></svg>";
219 const std::string FEGAUSS_SVG_LABEL2 =
220 "<svg width=\"-230\" height=\"-120\"><filter id=\"blurMe\"><feGaussianBlur in=\"Graphic\" stdDeviation=\"5\" "
221 "/></filter><circle cx=\"170\" cy=\"60\" r=\"50\" fill=\"green\" filter=\"url(#blurMe)\" /></svg>";
222 const std::string COMPOSITE_SVG_LABEL =
223 "<svg height=\"900\" width=\"900\"><filter id=\"composite\" y=\"0\" x=\"0\" width=\"100%\" "
224 "height=\"100%\"><feComposite in2=\"B\" "
225 "in=\"SourceGraphic\" operator=\"in\" /></filter><ellipse cx=\"100\" cy=\"87\" rx=\"75\" ry=\"87\" fill=\"red\" "
226 "filter=\"url(#composite)\"/></svg>";
227 const std::string COLOR_MATRIX_SVG_LABEL =
228 "<svg height=\"900\" width=\"900\"><filter id=\"linear\"><feColorMatrix type=\"matrix\" "
229 "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\" "
230 "rx=\"75\" ry=\"87\" fill=\"red\" filter=\"url(#linear)\"></ellipse></svg>";
231 const std::string TYPE = "matrix";
232 const std::string VALUE = "R 0 0 0 0 0 G 0 0 0 0 0 B 0 0 0 0 0 A 0";
233 const std::string ELLIPSE_SVG_LABEL1 =
234 "<svg fill=\"white\" width=\"400\" height=\"400\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><ellipse "
235 "cx=\"60\" cy=\"200\" rx=\"50\" ry=\"100\" stroke-width=\"4\" fill=\"red\" stroke=\"blue\"></ellipse></svg>";
236 const std::string ELLIPSE_SVG_LABEL2 =
237 "<svg fill=\"white\" width=\"10\" height=\"10\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><ellipse "
238 "cx=\"60\" cy=\"200\" rx=\"50\" ry=\"100\" stroke-width=\"4\" fill=\"red\" stroke=\"blue\"></ellipse></svg>";
239 const std::string ELLIPSE_SVG_LABEL3 =
240 "<svg fill=\"white\" width=\"10\" height=\"10\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><ellipse "
241 "cx=\"0.0\" cy=\"0.0\" rx=\"-1\" ry=\"-1\" stroke-width=\"4\" fill=\"red\" stroke=\"blue\"></ellipse></svg>";
242 const std::string ELLIPSE_SVG_LABEL4 =
243 "<svg fill=\"white\" width=\"10\" height=\"10\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\"><ellipse "
244 "cx=\"0.0\" cy=\"0.0\" rx=\"1\" ry=\"-1\" stroke-width=\"4\" fill=\"red\" stroke=\"blue\"></ellipse></svg>";
245 constexpr float ELLIPSE_CX = 60.0f;
246 constexpr float ELLIPSE_CY = 200.0f;
247 constexpr float ELLIPSE_RX = 50.0f;
248 constexpr float ELLIPSE_RY = 100.0f;
249 const std::string SVG_ANIMATE_TRANSFORM(
250 "<svg width=\"200px\" height=\"200px\" viewBox=\"0 0 100 100\" xmlns=\"http://www.w3.org/2000/svg\">"
251 "<path d =\"M50 50L20 50A30 30 0 0 0 80 50Z\">"
252 "<animateTransform attributeName =\"transform\" type=\"rotate\" repeatCount=\"3\" dur=\"1s\""
253 " values=\"0 50 50;45 50 50;0 50 50\" keyTimes=\"0;0.5;1\"></animateTransform></path></svg>");
254
255 const std::string NONE_STR = "";
256 const std::string SATURATE_VALUE = "10";
257 const std::string HUE_ROTATE = "80";
258 const std::string FE_COLOR_MATRIX =
259 "<svg width=\"900\" height=\"900\" viewBox=\"0 0 150 120\" xmlns=\"http://www.w3.org/2000/svg\">"
260 "<filter id=\"colorMatrix\">"
261 "<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\" />"
262 "<feColorMatrix type=\"saturate\" values=\"10\"/>"
263 "<feColorMatrix type=\"hueRotate\" values=\"80\"/>"
264 "<feColorMatrix type=\"luminanceToAlpha\" values=\"80\"/>"
265 "<feColorMatrix type=\"matrix\" values=\"1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0\" />"
266 "</filter>"
267 "<g>"
268 "<circle cx=\"30\" cy=\"30\" r=\"20\" fill=\"red\" fill-opacity=\"0.5\" />"
269 "</g>"
270 "<g filter=\"url(#colorMatrix)\">"
271 "<circle cx=\"80\" cy=\"30\" r=\"20\" fill=\"red\" fill-opacity=\"0.5\" />"
272 "</g>"
273 "</svg>";
274
275 const std::string FE_GAUSSIAN_BLUR =
276 "<svg width=\"900\" height=\"900\" viewBox=\"0 0 150 120\" xmlns=\"http://www.w3.org/2000/svg\">"
277 "<filter id=\"colorMatrix\">"
278 "<feGaussianBlur stdDeviation=\"10 50\"/>"
279 "<feGaussianBlur stdDeviation=\"10\"/>"
280 "<feGaussianBlur stdDeviation=\"abc abc\"/>"
281 "</filter>"
282 "<g>"
283 "<rect width=\"90\" height=\"90\" fill=\"#0099cc\" filter=\"url(#blurFilter)\" />"
284 "</g>"
285 "</svg>";
286
287 const std::string FE_FLOOD_AND_COMPOSITE =
288 "<svg width=\"900\" height=\"900\" viewBox=\"0 0 150 120\" >"
289 "<filter id=\"colorMatrix\">"
290 "<feFlood flood-color=\"red\" flood-opacity=\"0\" result=\"flood\" /><feFlood flood-color=\"green\" "
291 "flood-opacity=\"1\" result=\"flood1\" />"
292 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"xor\" result=\"composite\" k1=\"1\" "
293 "k2=\"0\"/></filter>"
294 "<g><rect width=\"90\" height=\"90\" fill=\"#0099cc\" filter=\"url(#blurFilter)\" /></g></svg>";
295
296 const std::string FE_COMPOSITE =
297 "<svg width=\"900\" height=\"900\" viewBox=\"0 0 150 120\" >"
298 "<filter id=\"colorMatrix\">"
299 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"undefine\" result=\"composite\" k1=\"1\" "
300 "k2=\"0\"/>"
301 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"arithmetic\" result=\"composite\" k1=\"1\" "
302 "k2=\"0\"/>"
303 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"atop\" result=\"composite\" k1=\"1\" "
304 "k2=\"0\"/>"
305 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"in\" result=\"composite\" k1=\"1\" "
306 "k2=\"0\"/>"
307 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"lighter\" result=\"composite\" k1=\"1\" "
308 "k2=\"0\"/>"
309 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"out\" result=\"composite\" k1=\"1\" "
310 "k2=\"0\"/>"
311 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"xor\" result=\"composite\" k1=\"1\" "
312 "k2=\"0\"/>"
313 "<feComposite in=\"SourceAlpha\" in2=\"SourceGraphic\" operator=\"over\" result=\"composite\" k1=\"1\" "
314 "k2=\"0\"/></filter>"
315 "<g><rect width=\"90\" height=\"90\" fill=\"#0099cc\" filter=\"url(#blurFilter)\" /></g></svg>";
316
317 const std::string FE_BLEND =
318 "<svg width=\"900\" height=\"900\" viewBox=\"0 0 150 120\" xmlns=\"http://www.w3.org/2000/svg\">"
319 "<filter id=\"colorMatrix\">"
320 "<feBlend in=\"SourceGraphic\" in2=\"SourceAlpha\" mode=\"lighten\" />"
321 "</filter>"
322 "<g>"
323 "<rect width=\"90\" height=\"90\" fill=\"#0099cc\" filter=\"url(#blurFilter)\" />"
324 "</g>"
325 "</svg>";
326
327 const std::string IMAGE_HREF = "test.png";
328 const std::string IMAGE_LABEL =
329 "<svg width=\"900\" height=\"900\" viewBox=\"0 0 150 120\" xmlns=\"http://www.w3.org/2000/svg\">"
330 "<image id=\"image001\" x=\"150\" y=\"20\" width=\"100\" height=\"100\" href=\"test.png\" />"
331 "</svg>";
332
333 constexpr float IMAGE_COMPONENT_WIDTH = 100.0f;
334 constexpr float IMAGE_COMPONENT_HEIGHT = 100.0f;
335
336 std::unordered_map<std::string, std::shared_ptr<RSImageFilter>> resultHash;
337 } // namespace
338 class ParseTestTwoNg : public testing::Test {
339 public:
340 static RefPtr<SvgDom> ParseRect(const std::string& svgLabel);
341 RefPtr<SvgDom> parsePolygon(const std::string& svgLable);
342 static RefPtr<SvgDom> ParsePath(const std::string& svgLabel);
343 RefPtr<SvgDom> ParseFeGaussianblur(const std::string& svgLabel);
344 static RefPtr<SvgDom> ParseEllipse(const std::string& svgLabel);
345 void CallBack(Testing::MockCanvas& rSCanvas);
SetUpTestSuite()346 static void SetUpTestSuite()
347 {
348 MockContainer::SetUp();
349 }
TearDownTestSuite()350 static void TearDownTestSuite()
351 {
352 MockContainer::TearDown();
353 }
354 };
355
ParseRect(const std::string & svgLabel)356 RefPtr<SvgDom> ParseTestTwoNg::ParseRect(const std::string& svgLabel)
357 {
358 auto svgStream = SkMemoryStream::MakeCopy(RECT_SVG_LABEL.c_str(), RECT_SVG_LABEL.length());
359 EXPECT_NE(svgStream, nullptr);
360 ImageSourceInfo src;
361 src.SetFillColor(Color::BLACK);
362 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
363 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
364 EXPECT_NE(svg, nullptr);
365 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
366 auto svgRect = AceType::DynamicCast<SvgRect>(svg->children_.at(0));
367 EXPECT_NE(svgRect, nullptr);
368 auto rectDeclaration = svgRect->rectAttr_;
369 EXPECT_FLOAT_EQ(rectDeclaration.x.ConvertToPx(), X);
370 EXPECT_FLOAT_EQ(rectDeclaration.y.ConvertToPx(), Y);
371 EXPECT_FLOAT_EQ(rectDeclaration.rx.ConvertToPx(), RX);
372 EXPECT_FLOAT_EQ(rectDeclaration.ry.ConvertToPx(), RY);
373 EXPECT_FLOAT_EQ(rectDeclaration.width.ConvertToPx(), RECT_WIDTH);
374 EXPECT_FLOAT_EQ(rectDeclaration.height.ConvertToPx(), RECT_HEIGHT);
375 return svgDom;
376 }
377
parsePolygon(const std::string & svgLable)378 RefPtr<SvgDom> ParseTestTwoNg::parsePolygon(const std::string& svgLable)
379 {
380 auto svgStream = SkMemoryStream::MakeCopy(svgLable.c_str(), svgLable.length());
381 EXPECT_NE(svgStream, nullptr);
382 ImageSourceInfo src;
383 src.SetFillColor(Color::BLACK);
384 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
385 EXPECT_NE(svgDom, nullptr);
386 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
387 EXPECT_NE(svg, nullptr);
388 EXPECT_EQ(static_cast<int32_t>(svg->children_.size()), CHILD_NUMBER);
389 auto svgPolygon = AceType::DynamicCast<SvgPolygon>(svg->children_.at(0));
390 EXPECT_NE(svgPolygon, nullptr);
391 auto svgPolyline = AceType::DynamicCast<SvgPolygon>(svg->children_.at(1));
392 EXPECT_NE(svgPolyline, nullptr);
393 auto polygonDeclaration = svgPolygon->polyAttr_;
394 EXPECT_STREQ(polygonDeclaration.points.c_str(), POLYGON_POINT.c_str());
395 auto polylineDeclaration = svgPolyline->polyAttr_;
396 EXPECT_STREQ(polylineDeclaration.points.c_str(), POLYLINE_POINT.c_str());
397 return svgDom;
398 }
399
ParsePath(const std::string & svgLabel)400 RefPtr<SvgDom> ParseTestTwoNg::ParsePath(const std::string& svgLabel)
401 {
402 auto svgStream = SkMemoryStream::MakeCopy(svgLabel.c_str(), svgLabel.length());
403 EXPECT_NE(svgStream, nullptr);
404 ImageSourceInfo src;
405 src.SetFillColor(Color::BLACK);
406 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
407 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
408 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
409 auto svgPath = AceType::DynamicCast<SvgPath>(svg->children_.at(0));
410 EXPECT_NE(svgPath, nullptr);
411 auto pathDeclaration = svgPath->d_;
412 EXPECT_STREQ(pathDeclaration.c_str(), PATH_CMD.c_str());
413 return svgDom;
414 }
415
ParseFeGaussianblur(const std::string & svgLabel)416 RefPtr<SvgDom> ParseTestTwoNg::ParseFeGaussianblur(const std::string& svgLabel)
417 {
418 auto svgStream = SkMemoryStream::MakeCopy(svgLabel.c_str(), svgLabel.length());
419 EXPECT_NE(svgStream, nullptr);
420 ImageSourceInfo src;
421 src.SetFillColor(Color::BLACK);
422 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
423 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
424 EXPECT_GT(svg->children_.size(), 0);
425 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
426 EXPECT_NE(svgFilter, nullptr);
427 auto svgFeGaussiaBlur = AceType::DynamicCast<SvgFeGaussianBlur>(svgFilter->children_.at(0));
428 EXPECT_NE(svgFeGaussiaBlur, nullptr);
429 auto feDeclaration = svgFeGaussiaBlur->gaussianBlurAttr_;
430 EXPECT_EQ(feDeclaration.edgeMode, SvgFeEdgeMode::EDGE_DUPLICATE);
431 return svgDom;
432 }
433
ParseEllipse(const std::string & svgLabel)434 RefPtr<SvgDom> ParseTestTwoNg::ParseEllipse(const std::string& svgLabel)
435 {
436 auto svgStream = SkMemoryStream::MakeCopy(svgLabel.c_str(), svgLabel.length());
437 EXPECT_NE(svgStream, nullptr);
438 ImageSourceInfo src;
439 src.SetFillColor(Color::BLACK);
440 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
441 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
442 EXPECT_GT(svg->children_.size(), 0);
443 auto svgEllipse = AceType::DynamicCast<SvgEllipse>(svg->children_.at(0));
444 EXPECT_NE(svgEllipse, nullptr);
445 auto ellipseDeclaration = svgEllipse->ellipseAttr_;
446 EXPECT_FLOAT_EQ(ellipseDeclaration.cx.ConvertToPx(), ELLIPSE_CX);
447 EXPECT_FLOAT_EQ(ellipseDeclaration.cy.ConvertToPx(), ELLIPSE_CY);
448 EXPECT_FLOAT_EQ(ellipseDeclaration.rx.ConvertToPx(), ELLIPSE_RX);
449 EXPECT_FLOAT_EQ(ellipseDeclaration.ry.ConvertToPx(), ELLIPSE_RY);
450 return svgDom;
451 }
452
CallBack(Testing::MockCanvas & rSCanvas)453 void ParseTestTwoNg::CallBack(Testing::MockCanvas& rSCanvas)
454 {
455 EXPECT_CALL(rSCanvas, AttachBrush(_)).WillRepeatedly(ReturnRef(rSCanvas));
456 EXPECT_CALL(rSCanvas, DetachBrush()).WillRepeatedly(ReturnRef(rSCanvas));
457 EXPECT_CALL(rSCanvas, AttachPen(_)).WillRepeatedly(ReturnRef(rSCanvas));
458 EXPECT_CALL(rSCanvas, DetachPen()).WillRepeatedly(ReturnRef(rSCanvas));
459 EXPECT_CALL(rSCanvas, DrawPath(_)).Times(AtLeast(1));
460 }
461
462 /**
463 * @tc.name: ParseLineTest002
464 * @tc.desc: Create an SvgLine and set path
465 * @tc.type: FUNC
466 */
467 HWTEST_F(ParseTestTwoNg, ParseLineTest002, TestSize.Level1)
468 {
469 /* *
470 * @tc.steps: step1. call AsPath
471 * @tc.expected: Execute function return value not is nullptr
472 */
473 auto svgLine = AccessibilityManager::MakeRefPtr<SvgLine>();
474 svgLine->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
475 EXPECT_NE(svgLine, nullptr);
476 }
477
478 /**
479 * @tc.name: ParseEllipseTest005
480 * @tc.desc: Create an SvgEllipse and set path
481 * @tc.type: FUNC
482 */
483 HWTEST_F(ParseTestTwoNg, ParseEllipseTest005, TestSize.Level1)
484 {
485 auto svgStream = SkMemoryStream::MakeCopy(ELLIPSE_SVG_LABEL3.c_str(), ELLIPSE_SVG_LABEL3.length());
486 EXPECT_NE(svgStream, nullptr);
487
488 /* *
489 * @tc.steps: step1. call CreateSvgDom
490 * @tc.expected: Execute function return value size not is 0
491 */
492 ImageSourceInfo src;
493 src.SetFillColor(Color::BLACK);
494 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
495 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
496 EXPECT_GT(svg->children_.size(), 0);
497
498 /* *
499 * @tc.steps: step2. call AsPath
500 * @tc.expected: Execute function return value not is nullptr
501 */
502 auto svgEllipse = AceType::DynamicCast<SvgEllipse>(svg->children_.at(0));
503 svgEllipse->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
504 EXPECT_NE(svgEllipse, nullptr);
505 }
506
507 /**
508 * @tc.name: ParseEllipseTest006
509 * @tc.desc: Create an SvgEllipse and set patha
510 * @tc.type: FUNC
511 */
512 HWTEST_F(ParseTestTwoNg, ParseEllipseTest006, TestSize.Level1)
513 {
514 auto svgStream = SkMemoryStream::MakeCopy(ELLIPSE_SVG_LABEL4.c_str(), ELLIPSE_SVG_LABEL4.length());
515 EXPECT_NE(svgStream, nullptr);
516
517 /* *
518 * @tc.steps: step1. call CreateSvgDom
519 * @tc.expected: Execute function return value size not is 0
520 */
521 ImageSourceInfo src;
522 src.SetFillColor(Color::BLACK);
523 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
524 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
525 EXPECT_GT(svg->children_.size(), 0);
526
527 /* *
528 * @tc.steps: step2. call AsPath
529 * @tc.expected: Execute function return value not is nullptr
530 */
531 auto svgEllipse = AceType::DynamicCast<SvgEllipse>(svg->children_.at(0));
532 svgEllipse->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
533 EXPECT_NE(svgEllipse, nullptr);
534 }
535
536 /**
537 * @tc.name: ParsePolygonTest003
538 * @tc.desc: parse polygon and polyline label
539 * @tc.type: FUNC
540 */
541 HWTEST_F(ParseTestTwoNg, ParsePolygonTest003, TestSize.Level1)
542 {
543 /* *
544 * @tc.steps: step1. call CreateSvgDom
545 * @tc.expected: Execute svgDom root node is 2
546 */
547 auto svgStream = SkMemoryStream::MakeCopy(POLYGON_SVG_LABEL1.c_str(), POLYGON_SVG_LABEL1.length());
548 ImageSourceInfo src;
549 src.SetFillColor(Color::BLACK);
550 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
551 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
552 EXPECT_EQ(static_cast<int32_t>(svg->children_.size()), CHILD_NUMBER);
553
554 /* *
555 * @tc.steps: step2. call AsPath
556 * @tc.expected: Execute SvgPolygon Points is empty
557 */
558 auto svgPolygon = AceType::DynamicCast<SvgPolygon>(svg->children_.at(0));
559 auto declaration = svgPolygon->polyAttr_;
560 declaration.points = "";
561 svgPolygon->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
562 EXPECT_TRUE(declaration.points.empty());
563
564 /* *
565 * @tc.steps: step3. call AsPath
566 * @tc.expected: Execute SvgPolygon Points parse error
567 */
568 declaration.points = "ccc";
569 svgPolygon->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
570 EXPECT_FALSE(declaration.points.empty());
571 }
572
573 /**
574 * @tc.name: ParsePolygonTest003
575 * @tc.desc: parse polygon and polyline label
576 * @tc.type: FUNC
577 */
578 HWTEST_F(ParseTestTwoNg, ParsePolygonTest004, TestSize.Level1)
579 {
580 auto polygon = AceType::DynamicCast<SvgPolygon>(AceType::MakeRefPtr<SvgPolygon>(true));
581 EXPECT_NE(polygon, nullptr);
582 std::vector<RSPoint> points;
583 RSPoint point1;
584 point1.SetX(1.0f);
585 point1.SetX(2.0f);
586 points.emplace_back(point1);
587
588 RSPoint point2;
589 point2.SetX(1.0f);
590 point2.SetX(2.0f);
591 points.emplace_back(point2);
592
593 SvgLengthScaleRule lengthScaleRule;
594 polygon->ConvertPoints(points, lengthScaleRule);
595 EXPECT_EQ(points.size(), 2);
596 }
597
598 /**
599 * @tc.name: ParsePolygonTest003
600 * @tc.desc: parse polygon and polyline label
601 * @tc.type: FUNC
602 */
603 HWTEST_F(ParseTestTwoNg, ParsePolygonTest005, TestSize.Level1)
604 {
605 int32_t backupApiVersion = MockContainer::Current()->GetApiTargetVersion();
606 MockContainer::Current()->SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_EIGHTEEN));
607 auto polygon = AceType::DynamicCast<SvgPolygon>(AceType::MakeRefPtr<SvgPolygon>(true));
608 EXPECT_NE(polygon, nullptr);
609
610 Size size;
611 auto result = polygon->AsPath(size);
612 EXPECT_TRUE(result.BuildFromSVGString(""));
613
614 polygon->polyAttr_.points = "no";
615 result = polygon->AsPath(size);
616 EXPECT_TRUE(result.BuildFromSVGString(""));
617
618 polygon->polyAttr_.points = "*aaaaaaaa|*aaaaaaaa|*aaaaaaaa|*aaaaaaaa|*aaaaaaaa|";
619 polygon->attributes_.clipState.clipRule_ = SvgRuleType::SVG_RULE_EVENODD;
620 polygon->attributes_.fillState.fillRule_ = "evenodd";
621 result = polygon->AsPath(size);
622 EXPECT_TRUE(result.BuildFromSVGString(""));
623 MockContainer::Current()->SetApiTargetVersion(backupApiVersion);
624 }
625
626 /**
627 * @tc.name: ParsePolygonTest003
628 * @tc.desc: parse polygon and polyline label
629 * @tc.type: FUNC
630 */
631 HWTEST_F(ParseTestTwoNg, ParsePolygonTest006, TestSize.Level1)
632 {
633 int32_t backupApiVersion = MockContainer::Current()->GetApiTargetVersion();
634 MockContainer::Current()->SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_TWELVE));
635 auto polygon = AceType::DynamicCast<SvgPolygon>(AceType::MakeRefPtr<SvgPolygon>(true));
636 EXPECT_NE(polygon, nullptr);
637
638 Size size;
639 auto result = polygon->AsPath(size);
640 EXPECT_TRUE(result.BuildFromSVGString(""));
641
642 polygon->polyAttr_.points = "no";
643 result = polygon->AsPath(size);
644 EXPECT_TRUE(result.BuildFromSVGString(""));
645
646 polygon->polyAttr_.points = "*aaaaaaaa|*aaaaaaaa|*aaaaaaaa|*aaaaaaaa|*aaaaaaaa|";
647 polygon->attributes_.clipState.clipRule_ = SvgRuleType::SVG_RULE_EVENODD;
648 polygon->attributes_.fillState.fillRule_ = "evenodd";
649 result = polygon->AsPath(size);
650 EXPECT_TRUE(result.BuildFromSVGString(""));
651 MockContainer::Current()->SetApiTargetVersion(backupApiVersion);
652 }
653
654 /**
655 * @tc.name: ParsePolygonTest003
656 * @tc.desc: parse polygon and polyline label
657 * @tc.type: FUNC
658 */
659 HWTEST_F(ParseTestTwoNg, ParsePolygonTest007, TestSize.Level1)
660 {
661 auto polygon = AceType::DynamicCast<SvgPolygon>(AceType::MakeRefPtr<SvgPolygon>(true));
662 EXPECT_NE(polygon, nullptr);
663 SvgLengthScaleRule rule;
664 RSRecordingPath path;
665 polygon->path_ = path;
666
667 auto result = polygon->AsPath(rule);
668 EXPECT_TRUE(result.BuildFromSVGString(""));
669
670 polygon->path_ = std::nullopt;
671 result = polygon->AsPath(rule);
672 EXPECT_TRUE(result.BuildFromSVGString(""));
673
674 polygon->polyAttr_.points = "no";
675 result = polygon->AsPath(rule);
676 EXPECT_TRUE(result.BuildFromSVGString(""));
677
678 polygon->polyAttr_.points = "*aaaaaaaa|*aaaaaaaa|*aaaaaaaa|*aaaaaaaa|*aaaaaaaa|";
679 polygon->attributes_.fillState.fillRule_ = "evenodd";
680 rule.pathTransform_ = true;
681 result = polygon->AsPath(rule);
682 EXPECT_TRUE(result.BuildFromSVGString(""));
683 }
684
685 /**
686 * @tc.name: SvgGTest001
687 * @tc.desc: parse polygon and polyline label
688 * @tc.type: FUNC
689 */
690 HWTEST_F(ParseTestTwoNg, SvgGTest001, TestSize.Level1)
691 {
692 auto svgG = AceType::DynamicCast<SvgG>(AceType::MakeRefPtr<SvgG>());
693 EXPECT_NE(svgG, nullptr);
694 auto svgG1 = SvgG::Create();
695 EXPECT_NE(svgG1, nullptr);
696 SvgLengthScaleRule lengthRule;
697 RSCanvas canvas;
698 svgG->ApplyOpacity(canvas);
699 svgG->attributes_.hasOpacity = true;
700 svgG->ApplyOpacity(canvas);
701 svgG->OnDraw(canvas, lengthRule);
702 Size size;
703 auto result = svgG->AsPath(size);
704 EXPECT_TRUE(result.BuildFromSVGString(""));
705 result = svgG->AsPath(lengthRule);
706 EXPECT_TRUE(result.BuildFromSVGString(""));
707 }
708
709 /**
710 * @tc.name: SvgGTest001
711 * @tc.desc: parse polygon and polyline label
712 * @tc.type: FUNC
713 */
714 HWTEST_F(ParseTestTwoNg, SvgPath001, TestSize.Level1)
715 {
716 auto svgPath = AceType::DynamicCast<SvgPath>(AceType::MakeRefPtr<SvgPath>());
717 EXPECT_NE(svgPath, nullptr);
718 SvgLengthScaleRule rule;
719 rule.lengthScaleUnit_ = SvgLengthScaleUnit::OBJECT_BOUNDING_BOX;
720 auto rect = svgPath->GetobjectBoundingBox(rule);
721 EXPECT_EQ(rect.Width(), 0);
722 EXPECT_EQ(rect.Height(), 0);
723 EXPECT_EQ(rect.Left(), 0);
724 EXPECT_EQ(rect.Top(), 0);
725
726 rule.lengthScaleUnit_ = SvgLengthScaleUnit::USER_SPACE_ON_USE;
727 rect = svgPath->GetobjectBoundingBox(rule);
728 EXPECT_EQ(rect.Width(), 1);
729 EXPECT_EQ(rect.Height(), 1);
730 EXPECT_EQ(rect.Left(), 0);
731 EXPECT_EQ(rect.Top(), 0);
732 }
733
734 /**
735 * @tc.name: SvgGTest001
736 * @tc.desc: parse polygon and polyline label
737 * @tc.type: FUNC
738 */
739 HWTEST_F(ParseTestTwoNg, SvgPath002, TestSize.Level1)
740 {
741 auto svgPath = AceType::DynamicCast<SvgPath>(AceType::MakeRefPtr<SvgPath>());
742 EXPECT_NE(svgPath, nullptr);
743 SvgLengthScaleRule rule;
744 auto result = svgPath->AsPath(rule);
745 EXPECT_TRUE(result.BuildFromSVGString(""));
746
747 RSRecordingPath path;
748 svgPath->path_ = path;
749
750 result = svgPath->AsPath(rule);
751 EXPECT_TRUE(result.BuildFromSVGString(""));
752
753 rule.pathTransform_ = true;
754 svgPath->path_ = std::nullopt;
755 result = svgPath->AsPath(rule);
756 EXPECT_TRUE(result.BuildFromSVGString(""));
757
758 svgPath->path_ = path;
759 result = svgPath->AsPath(rule);
760 EXPECT_TRUE(result.BuildFromSVGString(""));
761
762 svgPath->d_ = "123";
763 result = svgPath->AsPath(rule);
764 EXPECT_TRUE(result.BuildFromSVGString(""));
765
766 svgPath->attributes_.fillState.fillRule_ = "evenodd";
767 result = svgPath->AsPath(rule);
768 EXPECT_TRUE(result.BuildFromSVGString(""));
769 }
770
771 /**
772 * @tc.name: SvgGTest001
773 * @tc.desc: parse polygon and polyline label
774 * @tc.type: FUNC
775 */
776 HWTEST_F(ParseTestTwoNg, SvgFeGaussianBlurTest001, TestSize.Level1)
777 {
778 auto feGaussianBlur = AceType::DynamicCast<SvgFeGaussianBlur>(SvgFeGaussianBlur::Create());
779 EXPECT_NE(feGaussianBlur, nullptr);
780 std::shared_ptr<RSImageFilter> imageFilter = nullptr;
781 SvgColorInterpolationType type = SvgColorInterpolationType::SRGB;
782 SvgColorInterpolationType colorInterpolationType = SvgColorInterpolationType::SRGB;
783 std::unordered_map<std::string, std::shared_ptr<RSImageFilter>> resultHash;
784 feGaussianBlur->OnAsImageFilter(imageFilter, type, colorInterpolationType, resultHash, false);
785
786 feGaussianBlur->filterContext_.primitiveRule_.lengthScaleUnit_ = SvgLengthScaleUnit::USER_SPACE_ON_USE;
787 feGaussianBlur->OnAsImageFilter(imageFilter, type, colorInterpolationType, resultHash, true);
788
789 feGaussianBlur->filterContext_.primitiveRule_.lengthScaleUnit_ = SvgLengthScaleUnit::OBJECT_BOUNDING_BOX;
790 feGaussianBlur->OnAsImageFilter(imageFilter, type, colorInterpolationType, resultHash, true);
791
792 auto result = feGaussianBlur->ParseAndSetSpecializedAttr("edgemode", "aaaa");
793 EXPECT_TRUE(result);
794
795 result = feGaussianBlur->ParseAndSetSpecializedAttr("stddeviation", "1,2,4,6,76,43");
796 EXPECT_TRUE(result);
797
798 result = feGaussianBlur->ParseAndSetSpecializedAttr("stddeviation", "1 2 4 6 76 43");
799 EXPECT_TRUE(result);
800
801 result = feGaussianBlur->ParseAndSetSpecializedAttr("stddeviation", "1,2");
802 EXPECT_TRUE(result);
803 }
804
805 /**
806 * @tc.name: SvgGTest001
807 * @tc.desc: parse polygon and polyline label
808 * @tc.type: FUNC
809 */
810 HWTEST_F(ParseTestTwoNg, SvgPatternTest001, TestSize.Level1)
811 {
812 auto pattern = AceType::DynamicCast<SvgPattern>(SvgPattern::Create());
813 EXPECT_NE(pattern, nullptr);
814 RSCanvas canvas;
815 Size viewPort;
816 std::optional<Color> color = Color::BLACK;
817 int32_t settingApiVersion = static_cast<int32_t>(PlatformVersion::VERSION_TWELVE);
818 int32_t backupApiVersion = MockContainer::Current()->GetApiTargetVersion();
819 MockContainer::Current()->SetApiTargetVersion(settingApiVersion);
820 pattern->OnDrawTraversedBefore(canvas, viewPort, color);
821 MockContainer::Current()->SetApiTargetVersion(backupApiVersion);
822
823 pattern->patternAttr_.patternContentUnits = SvgLengthScaleUnit::OBJECT_BOUNDING_BOX;
824 pattern->OnDrawTraversedBefore(canvas, viewPort, color);
825 pattern->OnDrawTraversedAfter(canvas, viewPort, color);
826 RSBrush brush;
827 Rect rect(10, 12, 13, 15);
828 Size size(10, 10);
829 SvgCoordinateSystemContext context(rect, size);
830 RefPtr<SvgNode> svgNode1 = nullptr;
831 RefPtr<SvgNode> svgNode2 = SvgPattern::Create();
832 pattern->children_.emplace_back(svgNode1);
833 pattern->children_.emplace_back(svgNode2);
834 pattern->OnPatternEffect(canvas, brush, context);
835 EXPECT_TRUE(context.UseFillColor());
836 }
837
838 /**
839 * @tc.name: ParseStyleTest002
840 * @tc.desc: parse use label
841 * @tc.type: FUNC
842 */
843 HWTEST_F(ParseTestTwoNg, ParseStyleTest002, TestSize.Level1)
844 {
845 /* *
846 * @tc.steps: step1. call ParseCssStyle
847 * @tc.expected: Execute function return value false
848 */
849 SvgStyle::ParseCssStyle("", nullptr);
850 std::string str;
__anona52951970202(const std::string& key, const std::pair<std::string, std::string>& value) 851 PushAttr callback = [&str](const std::string& key, const std::pair<std::string, std::string>& value) { str = key; };
852 SvgStyle::ParseCssStyle("body {font-style: oblique;}.normal {font-style: normal;}", callback);
853 EXPECT_FALSE(str.empty());
854
855 SvgStyle::ParseCssStyle("body font-style: oblique;}. {font-style: normal;}", callback);
856 EXPECT_FALSE(str.empty());
857 }
858
859 /**
860 * @tc.name: ParseRectTest004
861 * @tc.desc: parse rect label
862 * @tc.type: FUNC
863 */
864 HWTEST_F(ParseTestTwoNg, ParseRectTest004, TestSize.Level1)
865 {
866 auto svgStream = SkMemoryStream::MakeCopy(RECT_SVG_LABEL3.c_str(), RECT_SVG_LABEL3.length());
867 ImageSourceInfo src;
868 src.SetFillColor(Color::BLACK);
869 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
870 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
871 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
872
873 /* *
874 * @tc.steps: step1. call AsPath
875 * @tc.expected: Execute function return value not is 0
876 */
877 auto svgRect = AceType::DynamicCast<SvgRect>(svg->children_.at(0));
878 svgRect->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
879 auto rectDeclaration = svgRect->rectAttr_;
880 EXPECT_NE(rectDeclaration.rx.Value(), 0);
881 }
882
883 /**
884 * @tc.name: ParseUseTest002
885 * @tc.desc: parse use label
886 * @tc.type: FUNC
887 */
888 HWTEST_F(ParseTestTwoNg, ParseUseTest002, TestSize.Level1)
889 {
890 auto svgStream = SkMemoryStream::MakeCopy(USE_SVG_LABEL.c_str(), USE_SVG_LABEL.length());
891 ImageSourceInfo src;
892 src.SetFillColor(Color::GREEN);
893 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
894 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
895 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
896
897 /* *
898 * @tc.steps: step1. call AsPath
899 * @tc.expected: Execute function return value is true
900 */
901 auto svgUse = AceType::DynamicCast<SvgUse>(svg->children_.at(INDEX_ONE));
902 svgUse->attributes_.href = "";
903 svgUse->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
904 EXPECT_TRUE(svgUse->attributes_.href.empty());
905 }
906
907 /**
908 * @tc.name: ParseImageTest001
909 * @tc.desc: parse image label
910 * @tc.type: FUNC
911 */
912 HWTEST_F(ParseTestTwoNg, ParseImageTest001, TestSize.Level1)
913 {
914 auto svgStream = SkMemoryStream::MakeCopy(IMAGE_LABEL.c_str(), IMAGE_LABEL.length());
915 ImageSourceInfo src;
916 src.SetFillColor(Color::BLACK);
917 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
918 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
919 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
920
921 /* *
922 * @tc.steps: step1. call AsPath
923 * @tc.expected: Execute function return value is true
924 */
925 auto svgImage = AceType::DynamicCast<SvgImage>(svg->children_.at(0));
926 auto imageDeclaration = svgImage->imageAttr_;
927 EXPECT_FLOAT_EQ(imageDeclaration.x.ConvertToPx(), X);
928 EXPECT_FLOAT_EQ(imageDeclaration.y.ConvertToPx(), Y);
929 EXPECT_FLOAT_EQ(imageDeclaration.width.ConvertToPx(), RECT_WIDTH);
930 EXPECT_FLOAT_EQ(imageDeclaration.height.ConvertToPx(), RECT_HEIGHT);
931 EXPECT_STREQ(imageDeclaration.href.c_str(), IMAGE_HREF.c_str());
932 }
933
934 /**
935 * @tc.name: ParseGradientTest001
936 * @tc.desc: parse Gradient set
937 * @tc.type: FUNC
938 */
939 HWTEST_F(ParseTestTwoNg, ParseGradientTest001, TestSize.Level1)
940 {
941 auto svgStream = SkMemoryStream::MakeCopy(CIRCLE_SVG_LABEL.c_str(), CIRCLE_SVG_LABEL.length());
942 EXPECT_NE(svgStream, nullptr);
943 ImageSourceInfo src;
944 src.SetFillColor(Color::BLACK);
945 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
946 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
947 EXPECT_GT(svg->children_.size(), 0);
948 auto svgCircle = AceType::DynamicCast<SvgCircle>(svg->children_.at(0));
949 EXPECT_NE(svgCircle, nullptr);
950
951 OHOS::Ace::Gradient gradient;
952 OHOS::Ace::LinearGradient linearGradientLocal;
953 linearGradientLocal.x1 = Dimension(1.0);
954 linearGradientLocal.x2 = Dimension(1.0);
955 linearGradientLocal.y1 = Dimension(1.0);
956 linearGradientLocal.y2 = Dimension(1.0);
957 gradient.SetLinearGradient(linearGradientLocal);
958 svgCircle->SetLinearGradient(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), gradient);
959 auto linearGradientInfo = gradient.GetLinearGradientInfo();
960 EXPECT_NE(linearGradientInfo.x1, 0.0);
961 linearGradientLocal.x1 = Dimension(1.0, DimensionUnit::PERCENT);
962 linearGradientLocal.x2 = Dimension(1.0, DimensionUnit::PERCENT);
963 linearGradientLocal.y1 = Dimension(1.0, DimensionUnit::PERCENT);
964 linearGradientLocal.y2 = Dimension(1.0, DimensionUnit::PERCENT);
965 gradient.SetLinearGradient(linearGradientLocal);
966 svgCircle->SetLinearGradient(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), gradient);
967 linearGradientInfo = gradient.GetLinearGradientInfo();
968 EXPECT_EQ(linearGradientInfo.x1, 0.0);
969
970 OHOS::Ace::RadialGradient radialGradientLocal;
971 radialGradientLocal.radialHorizontalSize = AnimatableDimension(1);
972 radialGradientLocal.radialCenterX = AnimatableDimension(1);
973 radialGradientLocal.radialCenterY = AnimatableDimension(1);
974 radialGradientLocal.fRadialCenterX = Dimension(1);
975 radialGradientLocal.fRadialCenterY = Dimension(1);
976 gradient.SetRadialGradient(radialGradientLocal);
977 auto radialGradientInfo = gradient.GetRadialGradientInfo();
978 EXPECT_EQ(radialGradientInfo.r, 0.0);
979 EXPECT_EQ(radialGradientInfo.cx, 0.0);
980 EXPECT_EQ(radialGradientInfo.cy, 0.0);
981 EXPECT_EQ(radialGradientInfo.fx, 0.0);
982 EXPECT_EQ(radialGradientInfo.fy, 0.0);
983 svgCircle->SetRadialGradient(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), gradient);
984 radialGradientInfo = gradient.GetRadialGradientInfo();
985 EXPECT_NE(radialGradientInfo.r, 0.0);
986 EXPECT_NE(radialGradientInfo.cx, 0.0);
987 EXPECT_NE(radialGradientInfo.cy, 0.0);
988 EXPECT_NE(radialGradientInfo.fx, 0.0);
989 EXPECT_NE(radialGradientInfo.fy, 0.0);
990 }
991
992 /**
993 * @tc.name: ParseGradientTest002
994 * @tc.desc: parse Gradient set
995 * @tc.type: FUNC
996 */
997 HWTEST_F(ParseTestTwoNg, ParseGradientTest002, TestSize.Level1)
998 {
__anona52951970302(const OHOS::Ace::Gradient& gradient) 999 std::function func = [&](const OHOS::Ace::Gradient& gradient) {
1000 auto svgStream = SkMemoryStream::MakeCopy(CIRCLE_SVG_LABEL.c_str(), CIRCLE_SVG_LABEL.length());
1001 EXPECT_NE(svgStream, nullptr);
1002 ImageSourceInfo src;
1003 src.SetFillColor(Color::BLACK);
1004 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1005 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1006 auto svgCircle = AceType::DynamicCast<SvgCircle>(svg->children_.at(0));
1007 EXPECT_NE(svgCircle, nullptr);
1008
1009 auto viewPort = Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT);
1010 auto baseAttr = svgCircle->GetBaseAttributes();
1011 svgCircle->fillState_.SetGradient(gradient);
1012 baseAttr.fillState.SetGradient(gradient);
1013 baseAttr.strokeState.SetGradient(gradient);
1014 svgCircle->SetBaseAttributes(baseAttr);
1015 svgCircle->SetGradientStyle(0);
1016 svgCircle->SetStrokeGradientStyle(0);
1017 svgCircle->UpdateFillGradient(viewPort);
1018 svgCircle->UpdateStrokeGradient(viewPort);
1019
1020 OHOS::Ace::RadialGradient radialGradientLocal;
1021 radialGradientLocal.radialHorizontalSize = AnimatableDimension(1);
1022 radialGradientLocal.radialCenterX = AnimatableDimension(1);
1023 radialGradientLocal.radialCenterY = AnimatableDimension(1);
1024 radialGradientLocal.fRadialCenterX = Dimension(1);
1025 radialGradientLocal.fRadialCenterY = Dimension(1);
1026 svgCircle->fillState_.SetGradient(gradient);
1027 baseAttr.fillState.SetGradient(gradient);
1028 baseAttr.strokeState.SetGradient(gradient);
1029 svgCircle->SetBaseAttributes(baseAttr);
1030 svgCircle->SetGradientStyle(1);
1031 svgCircle->SetStrokeGradientStyle(1);
1032 svgCircle->UpdateFillGradient(viewPort);
1033 svgCircle->UpdateStrokeGradient(viewPort);
1034 };
1035 OHOS::Ace::Gradient gradient;
1036 func(gradient);
1037 gradient.AddColor(OHOS::Ace::GradientColor(Color::RED));
1038 func(gradient);
1039 }
1040
1041 /**
1042 * @tc.name: ParseNodeTest001
1043 * @tc.desc: SvgNode SetAttr Parameters
1044 * @tc.type: FUNC
1045 */
1046 HWTEST_F(ParseTestTwoNg, ParseNodeTest001, TestSize.Level1)
1047 {
1048 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
1049 svgNode->SetAttr("stroke-dasharray", "");
1050
1051 svgNode->SetAttr("stroke-linecap", "round");
1052 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineCap(), LineCapStyle::ROUND);
1053
1054 svgNode->SetAttr("strokeLinecap", "square");
1055 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineCap(), LineCapStyle::SQUARE);
1056
1057 svgNode->SetAttr("stroke-linejoin", "bevel");
1058 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineJoin(), LineJoinStyle::BEVEL);
1059
1060 svgNode->SetAttr("strokeLinejoin", "round");
1061 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineJoin(), LineJoinStyle::ROUND);
1062
1063 svgNode->SetAttr("stroke-miterlimit", "0.1");
1064 EXPECT_NE(svgNode->GetBaseAttributes().strokeState.GetMiterLimit(), 0.1);
1065
1066 svgNode->SetAttr("stroke-miterlimit", "1.1");
1067 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetMiterLimit(), 1.1);
1068
1069 svgNode->SetAttr("strokeMiterlimit", "0.2");
1070 EXPECT_NE(svgNode->GetBaseAttributes().strokeState.GetMiterLimit(), 0.2);
1071
1072 svgNode->SetAttr("strokeMiterlimit", "1.2");
1073 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetMiterLimit(), 1.2);
1074
1075 svgNode->SetAttr("strokeOpacity", "0.321");
1076 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetOpacity().GetValue(), 0.321);
1077
1078 svgNode->SetAttr("strokeWidth", "1.2");
1079 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineWidth().Value(), 1.2);
1080
1081 svgNode->SetAttr("strokeWidth", "-1.2");
1082 EXPECT_NE(svgNode->GetBaseAttributes().strokeState.GetLineWidth().Value(), -1.2);
1083
1084 svgNode->SetAttr("stroke-width", "-1.2");
1085 EXPECT_NE(svgNode->GetBaseAttributes().strokeState.GetLineWidth().Value(), -1.2);
1086
1087 svgNode->SetAttr("strokeDasharray", "");
1088 svgNode->SetAttr("strokeDasharray", "1.1 1.2");
1089 auto tesData = std::vector { 1.1, 1.2 };
1090 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineDash().lineDash, tesData);
1091
1092 svgNode->SetAttr("strokeDashoffset", "2.0");
1093 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineDash().dashOffset, 2.0);
1094
1095 svgNode->SetAttr("transform-origin", "10 10");
1096 EXPECT_EQ(Dimension(10), svgNode->GetBaseAttributes().transformOrigin.first);
1097 EXPECT_EQ(Dimension(10), svgNode->GetBaseAttributes().transformOrigin.second);
1098
1099 svgNode->SetAttr("xlink:href", "test_xlink:href");
1100 EXPECT_NE(svgNode->GetBaseAttributes().href, "test_xlink:href");
1101 }
1102
1103 /**
1104 * @tc.name: ParseNodeTest002
1105 * @tc.desc: SvgNode test
1106 * @tc.type: FUNC
1107 */
1108 HWTEST_F(ParseTestTwoNg, ParseNodeTest002, TestSize.Level1)
1109 {
1110 auto svgStream = SkMemoryStream::MakeCopy(SVG_ANIMATE_TRANSFORM.c_str(), SVG_ANIMATE_TRANSFORM.length());
1111 ImageSourceInfo src;
1112 Size size;
1113 src.SetFillColor(Color::GREEN);
1114 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1115 EXPECT_NE(svgDom, nullptr);
1116 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1117 EXPECT_NE(svg, nullptr);
1118
1119 Testing::MockCanvas rSCanvas;
1120 CallBack(rSCanvas);
1121 svg->Draw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
1122 svg->OnFilter(rSCanvas, size);
1123 auto containerSize = svgDom->GetContainerSize();
1124 EXPECT_EQ(containerSize, SizeF(200.0f, 200.0f));
1125 svgDom->SetFillColor(Color::RED);
1126 EXPECT_EQ(svgDom->fillColor_.value(), Color::RED);
1127 svgDom->ControlAnimation(true);
1128 svgDom->SetSmoothEdge(1.1f);
1129 EXPECT_EQ(svgDom->smoothEdge_, 1.1f);
1130 }
1131
1132 /**
1133 * @tc.name: ParseNodeTest003
1134 * @tc.desc: SvgNode test
1135 * @tc.type: FUNC
1136 */
1137 HWTEST_F(ParseTestTwoNg, ParseNodeTest003, TestSize.Level1)
1138 {
1139 Size size;
1140 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
1141 auto dimension = Dimension(0.0, DimensionUnit::PERCENT);
1142
1143 SvgLengthType svgLengthType = static_cast<SvgLengthType>(int(SvgLengthType::OTHER) + 1);
1144 EXPECT_EQ(svgNode->ConvertDimensionToPx(dimension, size, svgLengthType), 0.0);
1145 dimension.SetUnit(DimensionUnit::AUTO);
1146 EXPECT_EQ(svgNode->ConvertDimensionToPx(dimension, size, svgLengthType), 0.0);
1147
1148 EXPECT_EQ(svgNode->ConvertDimensionToPx(dimension, 1.0), 0.0);
1149
1150 EXPECT_EQ(svgNode->GetRootViewBox(), Rect());
1151 }
1152
1153 /**
1154 * @tc.name: ParseNodeTest004
1155 * @tc.desc: SvgNode test
1156 * @tc.type: FUNC
1157 */
1158 HWTEST_F(ParseTestTwoNg, ParseNodeTest004, TestSize.Level1)
1159 {
1160 auto svgStream = SkMemoryStream::MakeCopy(SVG_ANIMATE_TRANSFORM.c_str(), SVG_ANIMATE_TRANSFORM.length());
1161 ImageSourceInfo src;
1162 Size size = { 100, 100 };
1163 src.SetFillColor(Color::GREEN);
1164 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
__anona52951970402() 1165 svgDom->SetAnimationOnFinishCallback([]() {});
1166 svgDom->SetColorFilter(std::nullopt);
1167 Testing::MockCanvas rSCanvas;
1168 CallBack(rSCanvas);
1169 svgDom->DrawImage(rSCanvas, ImageFit::SCALE_DOWN, size);
1170 }
1171
1172 /**
1173 * @tc.name: ParseNodeTest005
1174 * @tc.desc: SvgNode SetAttr Parameters
1175 * @tc.type: FUNC
1176 */
1177 HWTEST_F(ParseTestTwoNg, ParseNodeTest005, TestSize.Level1)
1178 {
1179 /* *
1180 * @tc.steps: step1. create svg node
1181 */
1182 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
1183
1184 /* *
1185 * @tc.steps: step2. set strokeLinecap
1186 * @tc.expected: The property is set successfully
1187 */
1188 svgNode->SetAttr("strokeLinecap", "butt");
1189 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineCap(), LineCapStyle::BUTT);
1190
1191 /* *
1192 * @tc.steps: step3. set strokeLinejoin
1193 * @tc.expected: The property is set successfully
1194 */
1195 svgNode->SetAttr("strokeLinejoin", "miter");
1196 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetLineJoin(), LineJoinStyle::MITER);
1197
1198 /* *
1199 * @tc.steps: step4. set fill
1200 * @tc.expected: The property is set successfully
1201 */
1202 int32_t settingApiVersion = static_cast<int32_t>(PlatformVersion::VERSION_EIGHTEEN);
1203 int32_t backupApiVersion = MockContainer::Current()->GetApiTargetVersion();
1204 MockContainer::Current()->SetApiTargetVersion(settingApiVersion);
1205
1206 svgNode->SetAttr("fill", "#003153");
1207 EXPECT_EQ(svgNode->GetBaseAttributes().fillState.GetColor().GetValue(), 0xFF003153);
1208 MockContainer::Current()->SetApiTargetVersion(backupApiVersion);
1209 }
1210
1211 /**
1212 * @tc.name: ParseAnimation001
1213 * @tc.desc: Test SvgAnimation SetAttr Method.
1214 * @tc.type: FUNC
1215 */
1216 HWTEST_F(ParseTestTwoNg, ParseAnimation001, TestSize.Level1)
1217 {
1218 auto svgAnimation = AccessibilityManager::MakeRefPtr<SvgAnimation>(SvgAnimateType::MOTION);
1219 EXPECT_NE(svgAnimation, nullptr);
1220
1221 svgAnimation->SetAttr("begin", "1000ms");
1222 svgAnimation->UpdateAttr();
1223 EXPECT_EQ(svgAnimation->GetBegin(), 1000);
1224
1225 svgAnimation->SetAttr("dur", "indefinite");
1226 svgAnimation->UpdateAttr();
1227 EXPECT_EQ(svgAnimation->GetDur(), 0);
1228
1229 svgAnimation->SetAttr("repeatcount", "indefinite");
1230 svgAnimation->UpdateAttr();
1231 EXPECT_EQ(svgAnimation->GetRepeatCount(), -1);
1232
1233 svgAnimation->SetAttr("keytimes", "");
1234 svgAnimation->UpdateAttr();
1235 EXPECT_EQ(svgAnimation->GetKeyTimes().size(), 0);
1236
1237 svgAnimation->SetAttr("keysplines", "");
1238 svgAnimation->UpdateAttr();
1239 EXPECT_EQ(svgAnimation->GetKeySplines().size(), 0);
1240
1241 svgAnimation->SetAttr("keysplines", "0.25;0.1;0.25;1");
1242 svgAnimation->UpdateAttr();
1243 EXPECT_EQ(svgAnimation->GetKeySplines().size(), 4);
1244
1245 svgAnimation->SetAttr("keypoints", "");
1246 svgAnimation->UpdateAttr();
1247 EXPECT_EQ(svgAnimation->GetKeyPoints().size(), 0);
1248
1249 svgAnimation->SetAttr("keypoints", "0;0.4;1");
1250 svgAnimation->UpdateAttr();
1251 EXPECT_EQ(svgAnimation->GetKeyPoints().size(), 3);
1252 }
1253
1254 /**
1255 * @tc.name: ParseAnimation002
1256 * @tc.desc: Test SvgAnimation CreatePropertyAnimation Method.
1257 * @tc.type: FUNC
1258 */
1259 HWTEST_F(ParseTestTwoNg, ParseAnimation002, TestSize.Level1)
1260 {
1261 auto svgAnimation = AccessibilityManager::MakeRefPtr<SvgAnimation>(SvgAnimateType::TRANSFORM);
1262 EXPECT_NE(svgAnimation, nullptr);
1263
1264 svgAnimation->SetAttr("begin", "1000ms");
1265 svgAnimation->UpdateAttr();
1266 EXPECT_EQ(svgAnimation->GetBegin(), 1000);
1267
__anona52951970502(double x) 1268 std::function<void(double)> callback = [](double x) -> void { x = 0; };
1269 const double value = 0;
1270 svgAnimation->values_ = { "1" };
1271 svgAnimation->CreatePropertyAnimation<double>(value, std::move(callback));
1272 EXPECT_NE(svgAnimation->animator_, nullptr);
1273 svgAnimation->animator_->Finish();
1274 EXPECT_EQ(svgAnimation->animator_->IsStopped(), true);
1275
1276 svgAnimation->CreatePropertyAnimation<double>(value, std::move(callback));
1277 EXPECT_EQ(svgAnimation->animator_->IsStopped(), false);
1278 }
1279
1280 /**
1281 * @tc.name: ParseAnimation003
1282 * @tc.desc: Create Animation SetAttr
1283 * @tc.type: FUNC
1284 */
1285 HWTEST_F(ParseTestTwoNg, ParseAnimation003, TestSize.Level1)
1286 {
1287 auto svgAnimation = AccessibilityManager::MakeRefPtr<SvgAnimation>(SvgAnimateType::MOTION);
1288 EXPECT_NE(svgAnimation, nullptr);
1289
1290 /* *
1291 * @tc.steps: step1. call SetAttr
1292 * @tc.expected: Attribute set successfully
1293 */
1294 svgAnimation->SetAttr("attributeName", "fill");
1295 svgAnimation->UpdateAttr();
1296 auto svg = SvgSvg::Create();
1297 EXPECT_NE(svg, nullptr);
1298 svg->PrepareAnimation(svgAnimation);
1299 EXPECT_EQ(svgAnimation->GetAttributeName(), "fill");
1300
1301 svgAnimation->SetAttr("calcmode", "paced");
1302 svgAnimation->UpdateAttr();
1303 EXPECT_EQ(svgAnimation->GetCalcMode(), CalcMode::PACED);
1304
1305 svgAnimation->SetAttr("from", "blue");
1306 svgAnimation->UpdateAttr();
1307 EXPECT_EQ(svgAnimation->GetFrom(), "blue");
1308
1309 svgAnimation->SetAttr("to", "red");
1310 svgAnimation->UpdateAttr();
1311 EXPECT_EQ(svgAnimation->GetTo(), "red");
1312
1313 svgAnimation->SetAttr("path", "M0 0 L100 100");
1314 svgAnimation->UpdateAttr();
1315 EXPECT_EQ(svgAnimation->GetPath(), "M0 0 L100 100");
1316
1317 svgAnimation->SetAttr("rotate", "45");
1318 svgAnimation->UpdateAttr();
1319 EXPECT_EQ(svgAnimation->GetRotate(), "45");
1320 }
1321
1322 /**
1323 * @tc.name: ParseStopTest001
1324 * @tc.desc: parse stop label
1325 * @tc.type: FUNC
1326 */
1327 HWTEST_F(ParseTestTwoNg, ParseStopTest001, TestSize.Level1)
1328 {
1329 int32_t settingApiVersion = static_cast<int32_t>(PlatformVersion::VERSION_EIGHTEEN);
1330 int32_t backupApiVersion = MockContainer::Current()->GetApiTargetVersion();
1331 MockContainer::Current()->SetApiTargetVersion(settingApiVersion);
1332
1333 /* *
1334 * @tc.steps: step1. create svgStop node
1335 */
1336 auto svgNode = SvgStop::Create();
1337 auto svgStop = AceType::DynamicCast<SvgStop>(svgNode);
1338 EXPECT_EQ(svgStop->stopAttr_.gradientColor.GetColor(), Color::BLACK);
1339
1340 /* *
1341 * @tc.steps: step2. parse stop-color
1342 * @tc.expected: The property is parse successfully
1343 */
1344 svgStop->ParseAndSetSpecializedAttr("stop-color", "rgba(0,49,83,255)");
1345 EXPECT_EQ(svgStop->stopAttr_.gradientColor.GetColor().GetValue(), 0xFF003153);
1346
1347 svgStop->ParseAndSetSpecializedAttr("stop-color", "rgb(0,49,83)");
1348 EXPECT_EQ(svgStop->stopAttr_.gradientColor.GetColor().GetValue(), 0xFF003153);
1349
1350 /* *
1351 * @tc.steps: step3. parse stopcolor
1352 * @tc.expected: The property is parse successfully
1353 */
1354 svgStop->ParseAndSetSpecializedAttr("stopColor", "rgb(49,49,83)");
1355 EXPECT_EQ(svgStop->stopAttr_.gradientColor.GetColor().GetValue(), 0xFF313153);
1356
1357 /* *
1358 * @tc.steps: step4. parse stopOpacity
1359 * @tc.expected: The property is parse successfully
1360 */
1361 svgStop->ParseAndSetSpecializedAttr("stopOpacity", "0.0");
1362 EXPECT_EQ(svgStop->GetGradientColor().GetOpacity(), 0.0);
1363
1364 /* *
1365 * @tc.steps: step5. parse properties that do not belong to SvgStop
1366 * @tc.expected: The property is parse unsuccessfully
1367 */
1368 bool parseResult = svgStop->ParseAndSetSpecializedAttr("strokeLinecap", "butt");
1369 EXPECT_FALSE(parseResult);
1370 MockContainer::Current()->SetApiTargetVersion(backupApiVersion);
1371 }
1372
1373 /**
1374 * @tc.name: ParseFeTest001
1375 * @tc.desc: parse fe label
1376 * @tc.type: FUNC
1377 */
1378 HWTEST_F(ParseTestTwoNg, ParseFeTest001, TestSize.Level1)
1379 {
1380 /* *
1381 * @tc.steps: step1. create fe node
1382 */
1383 auto svgFe = AccessibilityManager::MakeRefPtr<SvgFe>();
1384
1385 svgFe->ParseAndSetSpecializedAttr("color-interpolation-filters", "auto");
1386 EXPECT_EQ(svgFe->feAttr_.colorInterpolationType, SvgColorInterpolationType::AUTO);
1387
1388 svgFe->ParseAndSetSpecializedAttr("color-interpolation-filters", "SRGB");
1389 EXPECT_EQ(svgFe->feAttr_.colorInterpolationType, SvgColorInterpolationType::AUTO);
1390
1391 svgFe->ParseAndSetSpecializedAttr("height", "1px");
1392 EXPECT_EQ(svgFe->feAttr_.height, 1.0_px);
1393
1394 svgFe->ParseAndSetSpecializedAttr("width", "1px");
1395 EXPECT_EQ(svgFe->feAttr_.width, 1.0_px);
1396
1397 svgFe->ParseAndSetSpecializedAttr("x", "1px");
1398 EXPECT_EQ(svgFe->feAttr_.x, 1.0_px);
1399
1400 svgFe->ParseAndSetSpecializedAttr("y", "1px");
1401 EXPECT_EQ(svgFe->feAttr_.y, 1.0_px);
1402
1403 bool parseResult = svgFe->ParseAndSetSpecializedAttr("strokeLinecap", "butt");
1404 EXPECT_FALSE(parseResult);
1405
1406 std::shared_ptr<RSImageFilter> imageFilter = nullptr;
1407 SvgColorInterpolationType colorInterpolationType = SvgColorInterpolationType::SRGB;
1408 svgFe->GetImageFilter(imageFilter, colorInterpolationType, resultHash);
1409 EXPECT_EQ(svgFe->effectFilterArea_.Top(), 0.0f);
1410 EXPECT_EQ(svgFe->effectFilterArea_.Left(), 0.0f);
1411 }
1412
1413 /**
1414 * @tc.name: ParseFeBlenderTest001
1415 * @tc.desc: test fe blender
1416 * @tc.type: FUNC
1417 */
1418 HWTEST_F(ParseTestTwoNg, ParseFeBlenderTest001, TestSize.Level1)
1419 {
1420 /* *
1421 * @tc.steps: step1. create feBlend node
1422 */
1423 auto svgFeBlend = AccessibilityManager::MakeRefPtr<SvgFeBlend>();
1424
1425 svgFeBlend->ParseAndSetSpecializedAttr("in2", "undefine");
1426 SvgFeBlendAttribute svgFeBlendDeclaration = svgFeBlend->feBlendAttr_;
1427 EXPECT_EQ(svgFeBlendDeclaration.in2.id, "undefine");
1428 svgFeBlend->ParseAndSetSpecializedAttr("mode", "undefine");
1429 svgFeBlendDeclaration = svgFeBlend->feBlendAttr_;
1430 EXPECT_EQ(svgFeBlendDeclaration.blendMode, SvgFeBlendMode::NORMAL);
1431
1432 RSBlendMode rsBlendMode = svgFeBlend->GetBlendMode(SvgFeBlendMode::NORMAL);
1433 EXPECT_EQ(rsBlendMode, RSBlendMode::SRC_OVER);
1434 rsBlendMode = svgFeBlend->GetBlendMode(SvgFeBlendMode::MULTIPLY);
1435 EXPECT_EQ(rsBlendMode, RSBlendMode::MULTIPLY);
1436 rsBlendMode = svgFeBlend->GetBlendMode(SvgFeBlendMode::SCREEN);
1437 EXPECT_EQ(rsBlendMode, RSBlendMode::SCREEN);
1438 rsBlendMode = svgFeBlend->GetBlendMode(SvgFeBlendMode::DARKEN);
1439 EXPECT_EQ(rsBlendMode, RSBlendMode::DARKEN);
1440 rsBlendMode = svgFeBlend->GetBlendMode(SvgFeBlendMode::LIGHTEN);
1441 EXPECT_EQ(rsBlendMode, RSBlendMode::LIGHTEN);
1442 rsBlendMode = svgFeBlend->GetBlendMode(static_cast<SvgFeBlendMode>(8));
1443 EXPECT_EQ(rsBlendMode, RSBlendMode::SRC_OVER);
1444 }
1445
1446 /**
1447 * @tc.name: ParseFeColorMatrixTest001
1448 * @tc.desc: parse FeColorMatrix label
1449 * @tc.type: FUNC
1450 */
1451 HWTEST_F(ParseTestTwoNg, ParseFeColorMatrixTest001, TestSize.Level1)
1452 {
1453 auto svgStream = SkMemoryStream::MakeCopy(FE_COLOR_MATRIX.c_str(), FE_COLOR_MATRIX.length());
1454 EXPECT_NE(svgStream, nullptr);
1455 ImageSourceInfo src;
1456 src.SetFillColor(Color::BLACK);
1457 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1458 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1459 EXPECT_GT(svg->children_.size(), 0);
1460 // filter is first child in svg
1461 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
1462 EXPECT_NE(svgFilter, nullptr);
1463 // the first child in filter
1464 auto svgFeColorMatrix1 = AceType::DynamicCast<SvgFeColorMatrix>(svgFilter->children_.at(0));
1465 EXPECT_NE(svgFeColorMatrix1, nullptr);
1466 svgFeColorMatrix1->OnInitStyle();
1467 auto feColorDeclaration1 = svgFeColorMatrix1->matrixAttr_;
1468 EXPECT_EQ(feColorDeclaration1.type, SvgFeColorMatrixType::MATRIX);
1469 // the second child in filter
1470 auto svgFeColorMatrix2 = AceType::DynamicCast<SvgFeColorMatrix>(svgFilter->children_.at(1));
1471 EXPECT_NE(svgFeColorMatrix2, nullptr);
1472 svgFeColorMatrix2->OnInitStyle();
1473 auto feColorDeclaration2 = svgFeColorMatrix2->matrixAttr_;
1474 EXPECT_EQ(feColorDeclaration2.type, SvgFeColorMatrixType::SATURATE);
1475 // the third child in filter
1476 auto svgFeColorMatrix3 = AceType::DynamicCast<SvgFeColorMatrix>(svgFilter->children_.at(2));
1477 EXPECT_NE(svgFeColorMatrix3, nullptr);
1478 svgFeColorMatrix3->OnInitStyle();
1479 auto feColorDeclaration3 = svgFeColorMatrix3->matrixAttr_;
1480 EXPECT_EQ(feColorDeclaration3.type, SvgFeColorMatrixType::HUE_ROTATE);
1481 // the fourth child in filter
1482 auto svgFeColorMatrix4 = AceType::DynamicCast<SvgFeColorMatrix>(svgFilter->children_.at(3));
1483 EXPECT_NE(svgFeColorMatrix4, nullptr);
1484 svgFeColorMatrix4->OnInitStyle();
1485 auto feColorDeclaration4 = svgFeColorMatrix4->matrixAttr_;
1486 EXPECT_EQ(feColorDeclaration4.type, SvgFeColorMatrixType::LUMINACE_TO_ALPHA);
1487 // the fifth child in filter
1488 auto svgFeColorMatrix5 = AceType::DynamicCast<SvgFeColorMatrix>(svgFilter->children_.at(4));
1489 EXPECT_NE(svgFeColorMatrix5, nullptr);
1490 svgFeColorMatrix5->OnInitStyle();
1491 auto feColorDeclaration5 = svgFeColorMatrix5->matrixAttr_;
1492 EXPECT_EQ(feColorDeclaration5.type, SvgFeColorMatrixType::MATRIX);
1493 }
1494
1495 /**
1496 * @tc.name: ParseFeCompositeTest001
1497 * @tc.desc: parse Composite label
1498 * @tc.type: FUNC
1499 */
1500 HWTEST_F(ParseTestTwoNg, ParseFeCompositeTest001, TestSize.Level1)
1501 {
1502 auto svgStream = SkMemoryStream::MakeCopy(FE_COMPOSITE.c_str(), FE_COMPOSITE.length());
1503 EXPECT_NE(svgStream, nullptr);
1504 ImageSourceInfo src;
1505 src.SetFillColor(Color::BLACK);
1506 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1507 EXPECT_NE(svgDom, nullptr);
1508 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1509 EXPECT_GT(svg->children_.size(), 0);
1510 // filter is first child in svg
1511 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
1512 EXPECT_NE(svgFilter, nullptr);
1513 // the first child in filter
1514 auto svgFeComposite1 = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(0));
1515 EXPECT_NE(svgFeComposite1, nullptr);
1516 svgFeComposite1->ParseAndSetSpecializedAttr("operator", "undefine");
1517 SvgFeCompositeAttribute svgFeCompositeDeclaration = svgFeComposite1->feCompositeAttr_;
1518 EXPECT_EQ(svgFeCompositeDeclaration.operatorType, SvgFeOperatorType::FE_OVER);
1519
1520 std::shared_ptr<RSImageFilter> imageFilter = nullptr;
1521 SvgColorInterpolationType srcColor = SvgColorInterpolationType::SRGB;
1522 SvgColorInterpolationType currentColor = SvgColorInterpolationType::LINEAR_RGB;
1523 svgFeComposite1->feCompositeAttr_.operatorType = static_cast<SvgFeOperatorType>(8);
1524 svgFeComposite1->OnAsImageFilter(imageFilter, srcColor, currentColor, resultHash);
1525 RSBlendMode rsBlendMode = svgFeComposite1->BlendModeForOperator(SvgFeOperatorType::FE_ARITHMETIC);
1526 EXPECT_EQ(rsBlendMode, RSBlendMode::SRC_OVER);
1527
1528 auto svgFeComposite5 = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(4));
1529 EXPECT_NE(svgFeComposite5, nullptr);
1530 svgFeComposite5->OnAsImageFilter(imageFilter, srcColor, currentColor, resultHash);
1531 svgFeCompositeDeclaration = svgFeComposite5->feCompositeAttr_;
1532 EXPECT_EQ(svgFeCompositeDeclaration.operatorType, SvgFeOperatorType::FE_LIGHTER);
1533
1534 auto svgFeComposite6 = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(5));
1535 EXPECT_NE(svgFeComposite6, nullptr);
1536 svgFeComposite6->OnAsImageFilter(imageFilter, srcColor, currentColor, resultHash);
1537 svgFeCompositeDeclaration = svgFeComposite6->feCompositeAttr_;
1538 EXPECT_EQ(svgFeCompositeDeclaration.operatorType, SvgFeOperatorType::FE_OUT);
1539
1540 auto svgFeComposite7 = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(6));
1541 EXPECT_NE(svgFeComposite7, nullptr);
1542 svgFeComposite7->OnAsImageFilter(imageFilter, srcColor, currentColor, resultHash);
1543 svgFeCompositeDeclaration = svgFeComposite7->feCompositeAttr_;
1544 EXPECT_EQ(svgFeCompositeDeclaration.operatorType, SvgFeOperatorType::FE_XOR);
1545
1546 auto svgFeComposite8 = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(7));
1547 EXPECT_NE(svgFeComposite8, nullptr);
1548 svgFeComposite8->OnAsImageFilter(imageFilter, srcColor, currentColor, resultHash);
1549 svgFeCompositeDeclaration = svgFeComposite8->feCompositeAttr_;
1550 EXPECT_EQ(svgFeCompositeDeclaration.operatorType, SvgFeOperatorType::FE_OVER);
1551 }
1552
1553 /**
1554 * @tc.name: ParseFeCompositeTest002
1555 * @tc.desc: parse Composite label
1556 * @tc.type: FUNC
1557 */
1558 HWTEST_F(ParseTestTwoNg, ParseFeCompositeTest002, TestSize.Level1)
1559 {
1560 auto svgStream = SkMemoryStream::MakeCopy(FE_COMPOSITE.c_str(), FE_COMPOSITE.length());
1561 EXPECT_NE(svgStream, nullptr);
1562 ImageSourceInfo src;
1563 src.SetFillColor(Color::BLACK);
1564 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1565 EXPECT_NE(svgDom, nullptr);
1566 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1567 EXPECT_GT(svg->children_.size(), 0);
1568 // filter is first child in svg
1569 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
1570 EXPECT_NE(svgFilter, nullptr);
1571
1572 std::shared_ptr<RSImageFilter> imageFilter = nullptr;
1573 SvgColorInterpolationType srcColor = SvgColorInterpolationType::SRGB;
1574 SvgColorInterpolationType currentColor = SvgColorInterpolationType::LINEAR_RGB;
1575 auto svgFeComposite5 = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(4));
1576 EXPECT_NE(svgFeComposite5, nullptr);
1577 svgFeComposite5->OnAsImageFilter(imageFilter, srcColor, currentColor, resultHash);
1578 SvgFeCompositeAttribute svgFeCompositeDeclaration = svgFeComposite5->feCompositeAttr_;
1579 EXPECT_EQ(svgFeCompositeDeclaration.operatorType, SvgFeOperatorType::FE_LIGHTER);
1580
1581 auto svgFeComposite6 = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(5));
1582 EXPECT_NE(svgFeComposite6, nullptr);
1583 svgFeComposite6->OnAsImageFilter(imageFilter, srcColor, currentColor, resultHash);
1584 svgFeCompositeDeclaration = svgFeComposite6->feCompositeAttr_;
1585 EXPECT_EQ(svgFeCompositeDeclaration.operatorType, SvgFeOperatorType::FE_OUT);
1586
1587 auto svgFeComposite7 = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(6));
1588 EXPECT_NE(svgFeComposite7, nullptr);
1589 svgFeComposite7->OnAsImageFilter(imageFilter, srcColor, currentColor, resultHash);
1590 svgFeCompositeDeclaration = svgFeComposite7->feCompositeAttr_;
1591 EXPECT_EQ(svgFeCompositeDeclaration.operatorType, SvgFeOperatorType::FE_XOR);
1592
1593 auto svgFeComposite8 = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(7));
1594 EXPECT_NE(svgFeComposite8, nullptr);
1595 svgFeComposite8->OnAsImageFilter(imageFilter, srcColor, currentColor, resultHash);
1596 svgFeCompositeDeclaration = svgFeComposite8->feCompositeAttr_;
1597 EXPECT_EQ(svgFeCompositeDeclaration.operatorType, SvgFeOperatorType::FE_OVER);
1598 }
1599
1600 HWTEST_F(ParseTestTwoNg, ParseFeGaussianBlurTest001, TestSize.Level1)
1601 {
1602 auto svgStream = SkMemoryStream::MakeCopy(FE_GAUSSIAN_BLUR.c_str(), FE_GAUSSIAN_BLUR.length());
1603 EXPECT_NE(svgStream, nullptr);
1604 ImageSourceInfo src;
1605 src.SetFillColor(Color::BLACK);
1606 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1607 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1608 EXPECT_GT(svg->children_.size(), 0);
1609 // filter is first child in svg
1610 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
1611 EXPECT_NE(svgFilter, nullptr);
1612 // the first child in filter
1613 auto svgFeGaussianBlur1 = AceType::DynamicCast<SvgFeGaussianBlur>(svgFilter->children_.at(0));
1614 EXPECT_NE(svgFeGaussianBlur1, nullptr);
1615
1616 auto bResult = svgFeGaussianBlur1->ParseAndSetSpecializedAttr("stddeviation", "");
1617 EXPECT_TRUE(bResult);
1618 }
1619
1620 /**
1621 * @tc.name: ParseFeOffsetTest001
1622 * @tc.desc: test fe offset
1623 * @tc.type: FUNC
1624 */
1625 HWTEST_F(ParseTestTwoNg, ParseFeOffsetTest001, TestSize.Level1)
1626 {
1627 /* *
1628 * @tc.steps: step1. create feOffset node
1629 */
1630 auto svgFeOffset = AccessibilityManager::MakeRefPtr<SvgFeOffset>();
1631
1632 svgFeOffset->ParseAndSetSpecializedAttr("dx", "5");
1633 auto svgFeOffsetAttribute = svgFeOffset->feOffsetAttr_;
1634 EXPECT_EQ(svgFeOffsetAttribute.dx, Dimension(5));
1635
1636 auto bResult = svgFeOffset->ParseAndSetSpecializedAttr("undefine", "undefine");
1637 EXPECT_FALSE(bResult);
1638 }
1639
1640 /**
1641 * @tc.name: ParseMaskTest001
1642 * @tc.desc: test Mask
1643 * @tc.type: FUNC
1644 */
1645 HWTEST_F(ParseTestTwoNg, ParseMaskTest001, TestSize.Level1)
1646 {
1647 /* *
1648 * @tc.steps: step1. create svgMask node
1649 */
1650 auto svgMask = AceType::DynamicCast<SvgMask>(SvgMask::Create());
1651 EXPECT_NE(svgMask, nullptr);
1652
1653 svgMask->ParseAndSetSpecializedAttr("y", "5");
1654 auto svgMaskAttribute = svgMask->maskAttr_;
1655 EXPECT_EQ(svgMaskAttribute.y, Dimension(5));
1656 auto attrValue = svgMask->ParseUnitsAttr(Dimension(1.0, DimensionUnit::PERCENT), 2.0);
1657 EXPECT_EQ(attrValue, 2.0);
1658 attrValue = svgMask->ParseUnitsAttr(Dimension(1.0), 2.0);
1659 EXPECT_EQ(attrValue, 2.0);
1660
1661 svgMask->isDefaultMaskUnits_ = false;
1662 attrValue = svgMask->ParseUnitsAttr(Dimension(1.0), 2.0);
1663 EXPECT_EQ(attrValue, 1.0);
1664 attrValue = svgMask->ParseUnitsAttr(Dimension(1.0, DimensionUnit::PERCENT), 2.0);
1665 EXPECT_EQ(attrValue, 2.0);
1666 }
1667
1668
1669 /**
1670 * @tc.name: ParseMaskTest001
1671 * @tc.desc: test Mask
1672 * @tc.type: FUNC
1673 */
1674 HWTEST_F(ParseTestTwoNg, ParseMaskTest002, TestSize.Level1)
1675 {
1676 auto svgMask = AceType::DynamicCast<SvgMask>(SvgMask::Create());
1677 EXPECT_NE(svgMask, nullptr);
1678 RSCanvas canvas;
1679 Rect rect(10, 12, 13, 15);
1680 Size size(10, 10);
1681 SvgCoordinateSystemContext context(rect, size);
1682 svgMask->OnMaskEffect(canvas, context);
1683
1684 SvgLengthScaleRule lengthRule;
1685 svgMask->smoothEdge_ = false;
1686
1687 RefPtr<SvgNode> svgNode1 = nullptr;
1688 RefPtr<SvgNode> svgNode2 = SvgPattern::Create();
1689 svgNode2->drawTraversed_ = false;
1690 RefPtr<SvgNode> svgNode3 = SvgPattern::Create();
1691 svgNode3->drawTraversed_ = true;
1692 svgMask->children_.emplace_back(svgNode1);
1693 svgMask->children_.emplace_back(svgNode2);
1694 svgMask->children_.emplace_back(svgNode3);
1695
1696 svgMask->DrawChildren(canvas, lengthRule);
1697 EXPECT_TRUE(lengthRule.UseFillColor());
1698
1699 svgMask->smoothEdge_ = true;
1700 svgMask->DrawChildren(canvas, lengthRule);
1701 EXPECT_TRUE(lengthRule.UseFillColor());
1702 }
1703
1704 /**
1705 * @tc.name: ParseMaskTest001
1706 * @tc.desc: test Mask
1707 * @tc.type: FUNC
1708 */
1709 HWTEST_F(ParseTestTwoNg, ParseMaskTest003, TestSize.Level1)
1710 {
1711 auto svgMask = AceType::DynamicCast<SvgMask>(SvgMask::Create());
1712 EXPECT_NE(svgMask, nullptr);
1713 int32_t settingApiVersion = static_cast<int32_t>(PlatformVersion::VERSION_EIGHTEEN);
1714 int32_t backupApiVersion = MockContainer::Current()->GetApiTargetVersion();
1715 MockContainer::Current()->SetApiTargetVersion(settingApiVersion);
1716 auto result = svgMask->ParseAndSetSpecializedAttr("maskunits", "objectBoundingBox");
1717 EXPECT_TRUE(result);
1718 result = svgMask->ParseAndSetSpecializedAttr("maskunits", "objectBoundingBox222");
1719 EXPECT_TRUE(result);
1720 MockContainer::Current()->SetApiTargetVersion(backupApiVersion);
1721 }
1722
1723
1724 /**
1725 * @tc.name: ParseFilterTest002
1726 * @tc.desc: parse Filter label
1727 * @tc.type: FUNC
1728 */
1729 HWTEST_F(ParseTestTwoNg, ParseFilterTest003, TestSize.Level1)
1730 {
1731 int32_t settingApiVersion = static_cast<int32_t>(PlatformVersion::VERSION_EIGHTEEN);
1732 int32_t backupApiVersion = MockContainer::Current()->GetApiTargetVersion();
1733 MockContainer::Current()->SetApiTargetVersion(settingApiVersion);
1734 auto svgStream = SkMemoryStream::MakeCopy(FE_COLOR_MATRIX.c_str(), FE_COLOR_MATRIX.length());
1735 EXPECT_NE(svgStream, nullptr);
1736
1737 ImageSourceInfo src;
1738 src.SetFillColor(Color::BLACK);
1739
1740 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1741 EXPECT_NE(svgDom, nullptr);
1742
1743 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1744 EXPECT_NE(svg, nullptr);
1745 EXPECT_GT(svg->children_.size(), 0);
1746
1747 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
1748 EXPECT_NE(svgFilter, nullptr);
1749
1750 svgFilter->children_.at(0) = nullptr;
1751 svgFilter->OnAsPaint();
1752 auto nodeFe1 = AceType::DynamicCast<SvgFe>(svgFilter->children_.at(0));
1753 auto nodeFe2 = AceType::DynamicCast<SvgFe>(svgFilter->children_.at(1));
1754 EXPECT_EQ(nodeFe1, nullptr);
1755 EXPECT_NE(nodeFe2, nullptr);
1756 MockContainer::Current()->SetApiTargetVersion(backupApiVersion);
1757 }
1758
1759 /**
1760 * @tc.name: ParseFilterTest002
1761 * @tc.desc: parse Filter label
1762 * @tc.type: FUNC
1763 */
1764 HWTEST_F(ParseTestTwoNg, ParseFilterTest004, TestSize.Level1)
1765 {
1766 auto svgFilter = AceType::DynamicCast<SvgFilter>(SvgFilter::Create());
1767 EXPECT_NE(svgFilter, nullptr);
1768 RSCanvas canvas;
1769 Rect rect(10, 12, 13, 15);
1770 Size size(10, 10);
1771 SvgCoordinateSystemContext context(rect, size);
1772 float useOffsetX = 10.f;
1773 float useOffsetY = 10.f;
1774
1775 RefPtr<SvgNode> svgNode1 = nullptr;
1776 RefPtr<SvgNode> svgNode2 = SvgPattern::Create();
1777 svgFilter->children_.emplace_back(svgNode1);
1778 svgFilter->children_.emplace_back(svgNode2);
1779 svgFilter->OnFilterEffect(canvas, context, useOffsetX, useOffsetY);
1780 EXPECT_TRUE(context.UseFillColor());
1781 }
1782
1783 /**
1784 * @tc.name: ParseRectTest005
1785 * @tc.desc: parse rect label
1786 * @tc.type: FUNC
1787 */
1788 HWTEST_F(ParseTestTwoNg, ParseRectTest005, TestSize.Level1)
1789 {
1790 auto svgStream = SkMemoryStream::MakeCopy(RECT_SVG_LABEL4.c_str(), RECT_SVG_LABEL4.length());
1791 ImageSourceInfo src;
1792 src.SetFillColor(Color::BLACK);
1793 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1794 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1795 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
1796
1797 /* *
1798 * @tc.steps: step1. call AsPath
1799 * @tc.expected: Execute function return value not is 0
1800 */
1801 auto svgRect = AceType::DynamicCast<SvgRect>(svg->children_.at(0));
1802 EXPECT_NE(svgRect, nullptr);
1803 svgRect->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1804 auto rectDeclaration = svgRect->rectAttr_;
1805 EXPECT_NE(rectDeclaration.rx.Value(), 0);
1806 }
1807
1808 /**
1809 * @tc.name: ParseUseTest003
1810 * @tc.desc: parse use label
1811 * @tc.type: FUNC
1812 */
1813 HWTEST_F(ParseTestTwoNg, ParseUseTest003, TestSize.Level1)
1814 {
1815 auto svgStream = SkMemoryStream::MakeCopy(USE_SVG_LABEL.c_str(), USE_SVG_LABEL.length());
1816 EXPECT_NE(svgStream, nullptr);
1817
1818 ImageSourceInfo src;
1819 src.SetFillColor(Color::GREEN);
1820
1821 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1822 EXPECT_NE(svgDom, nullptr);
1823
1824 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1825 EXPECT_NE(svg, nullptr);
1826 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
1827
1828 auto svgUse = AceType::DynamicCast<SvgUse>(svg->children_.at(INDEX_ONE));
1829 EXPECT_NE(svgUse, nullptr);
1830
1831 Testing::MockCanvas rSCanvas;
1832 CallBack(rSCanvas);
1833 svgUse->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1834 svgUse->useAttr_.x = Dimension(1.0, DimensionUnit::PERCENT);
1835 svgUse->useAttr_.y = Dimension(1.0, DimensionUnit::PERCENT);
1836 svgUse->OnDraw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
1837 svgUse->useAttr_.x = Dimension(0.0, DimensionUnit::PERCENT);
1838 svgUse->OnDraw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
1839 svgUse->attributes_.href = "";
1840 svgUse->OnDraw(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
1841
1842 auto bResult = svgUse->ParseAndSetSpecializedAttr("viewBox", "");
1843 EXPECT_TRUE(bResult);
1844
1845 svgUse->ParseAndSetSpecializedAttr("viewBox", "0 0 0 10");
1846 EXPECT_EQ(svgUse->useAttr_.viewBox.Height(), 10.0);
1847 svgUse->ParseAndSetSpecializedAttr("viewBox", "0 0 10");
1848 EXPECT_EQ(svgUse->useAttr_.viewBox.Height(), 10.0);
1849
1850 bResult = svgUse->ParseAndSetSpecializedAttr("viewbox", "");
1851 EXPECT_TRUE(bResult);
1852
1853 svgUse->ParseAndSetSpecializedAttr("viewbox", "0 0 24");
1854 EXPECT_EQ(svgUse->useAttr_.viewBox.Width(), 0.0);
1855 svgUse->ParseAndSetSpecializedAttr("viewbox", "0 0 10 10");
1856 EXPECT_EQ(svgUse->useAttr_.viewBox.Width(), 10.0);
1857
1858 bResult = svgUse->ParseAndSetSpecializedAttr("undefine", "");
1859 EXPECT_FALSE(bResult);
1860 }
1861
1862 /**
1863 * @tc.name: ParseSvgTest001
1864 * @tc.desc: parse svg label
1865 * @tc.type: FUNC
1866 */
1867 HWTEST_F(ParseTestTwoNg, ParseSvgTest001, TestSize.Level1)
1868 {
1869 auto svgStream = SkMemoryStream::MakeCopy(USE_SVG_LABEL.c_str(), USE_SVG_LABEL.length());
1870 EXPECT_NE(svgStream, nullptr);
1871
1872 ImageSourceInfo src;
1873 src.SetFillColor(Color::GREEN);
1874
1875 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1876 EXPECT_NE(svgDom, nullptr);
1877
1878 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1879 EXPECT_NE(svg, nullptr);
1880
1881 Testing::MockCanvas rSCanvas;
1882 EXPECT_CALL(rSCanvas, AttachBrush(_)).WillRepeatedly(ReturnRef(rSCanvas));
1883 EXPECT_CALL(rSCanvas, DetachBrush()).WillRepeatedly(ReturnRef(rSCanvas));
1884 EXPECT_CALL(rSCanvas, AttachPen(_)).WillRepeatedly(ReturnRef(rSCanvas));
1885 EXPECT_CALL(rSCanvas, DetachPen()).WillRepeatedly(ReturnRef(rSCanvas));
1886
1887 svg->svgAttr_.width = Dimension(1.0);
1888 svg->svgAttr_.height = Dimension(-1.0);
1889 svg->AdjustContentAreaByViewBox(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1890 svg->svgAttr_.height = Dimension(1.0);
1891 svg->svgAttr_.width = Dimension(-1.0);
1892 svg->AdjustContentAreaByViewBox(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1893 svg->svgAttr_.height = Dimension(-1.0);
1894 svg->AdjustContentAreaByViewBox(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1895 svg->svgAttr_.viewBox.height_ = 0.0;
1896 svg->AdjustContentAreaByViewBox(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1897 svg->svgAttr_.viewBox.width_ = 0.0;
1898 svg->AdjustContentAreaByViewBox(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1899
1900 auto bResult = svg->ParseAndSetSpecializedAttr("viewBox", "");
1901 EXPECT_TRUE(bResult);
1902 svg->ParseAndSetSpecializedAttr("viewBox", "0 0 10");
1903 EXPECT_EQ(svg->GetViewBox().Height(), 0.0);
1904 svg->ParseAndSetSpecializedAttr("viewBox", "0 0 0 10");
1905 EXPECT_EQ(svg->GetViewBox().Height(), 10.0);
1906 svg->ParseAndSetSpecializedAttr("viewbox", "0 0 10");
1907 EXPECT_EQ(svg->GetViewBox().Width(), 0.0);
1908 svg->ParseAndSetSpecializedAttr("viewbox", "0 0 10 10");
1909 EXPECT_EQ(svg->GetViewBox().Width(), 10.0);
1910 bResult = svg->ParseAndSetSpecializedAttr("viewbox", "");
1911 EXPECT_TRUE(bResult);
1912 }
1913
1914 /**
1915 * @tc.name: ParsePathTest001
1916 * @tc.desc: parse path label
1917 * @tc.type: FUNC
1918 */
1919 HWTEST_F(ParseTestTwoNg, ParsePathTest001, TestSize.Level1)
1920 {
1921 auto svgStream = SkMemoryStream::MakeCopy(PATH_SVG_LABEL1.c_str(), PATH_SVG_LABEL1.length());
1922 EXPECT_NE(svgStream, nullptr);
1923
1924 ImageSourceInfo src;
1925 src.SetFillColor(Color::BLACK);
1926
1927 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
1928 EXPECT_NE(svgDom, nullptr);
1929
1930 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
1931 EXPECT_NE(svg, nullptr);
1932 EXPECT_GT(static_cast<int32_t>(svg->children_.size()), 0);
1933
1934 auto svgPath = AceType::DynamicCast<SvgPath>(svg->children_.at(0));
1935 EXPECT_NE(svgPath, nullptr);
1936
1937 svgPath->attributes_.fillState.SetFillRule("evenodd");
1938 svgPath->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1939 EXPECT_TRUE(svgPath->attributes_.fillState.IsEvenodd());
1940
1941 svgPath->d_ = "";
1942 svgPath->AsPath(Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT));
1943 EXPECT_TRUE(svgPath->d_.empty());
1944 }
1945
1946 /**
1947 * @tc.name: ParseFeTest002
1948 * @tc.desc: Test SvgFe Method
1949 * @tc.type: FUNC
1950 */
1951 HWTEST_F(ParseTestTwoNg, ParseFeTest002, TestSize.Level1)
1952 {
1953 /* *
1954 * @tc.steps: step1. call MakeRefPtr<SvgFe>()
1955 * @tc.expected: Execute function return value not is nullptr
1956 */
1957 auto svgFe = AccessibilityManager::MakeRefPtr<SvgFe>();
1958 EXPECT_NE(svgFe, nullptr);
1959
1960 /* *
1961 * @tc.steps: step2. call MakeImageFilter
1962 * @tc.expected: Execute function return value not is nullptr
1963 */
1964 std::shared_ptr<RSImageFilter> imageFilter = nullptr;
1965 SvgFeIn in = { .in = SvgFeInType::SOURCE_GRAPHIC, .id = "test" };
1966
1967 in.in = SvgFeInType::PRIMITIVE;
1968 auto value = svgFe->MakeImageFilter(in, imageFilter, resultHash);
1969 EXPECT_EQ(value, nullptr);
1970
1971 /* *
1972 * @tc.steps: step3. call RegisterResult
1973 * @tc.expected: Register Successfully
1974 */
1975 svgFe->RegisterResult("test", imageFilter, resultHash);
1976 EXPECT_TRUE(resultHash.find("test") != resultHash.end());
1977
1978 SvgColorInterpolationType colorInterpolationType = SvgColorInterpolationType::SRGB;
1979 svgFe->feAttr_.in.in = SvgFeInType::SOURCE_GRAPHIC;
1980 svgFe->GetImageFilter(imageFilter, colorInterpolationType, resultHash);
1981
1982 colorInterpolationType = SvgColorInterpolationType::LINEAR_RGB;
1983 SvgColorInterpolationType srcColor = SvgColorInterpolationType::LINEAR_RGB;
1984 svgFe->ConverImageFilterColor(imageFilter, srcColor, colorInterpolationType);
1985
1986 value = svgFe->MakeImageFilter(in, imageFilter, resultHash);
1987 EXPECT_EQ(value, nullptr);
1988 }
1989
1990 /**
1991 * @tc.name: ParsePatternTest001
1992 * @tc.desc: parse pattern label
1993 * @tc.type: FUNC
1994 */
1995 HWTEST_F(ParseTestTwoNg, ParsePatternTest001, TestSize.Level1)
1996 {
1997 auto svgStream = SkMemoryStream::MakeCopy(PATTERN_SVG_LABEL.c_str(), PATTERN_SVG_LABEL.length());
1998 EXPECT_NE(svgStream, nullptr);
1999
2000 ImageSourceInfo src;
2001 src.SetFillColor(Color::BLACK);
2002
2003 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
2004 EXPECT_NE(svgDom, nullptr);
2005
2006 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
2007 EXPECT_NE(svg, nullptr);
2008 EXPECT_GT(svg->children_.size(), 0);
2009
2010 auto svgDefs = AceType::DynamicCast<SvgDefs>(svg->children_.at(0));
2011 EXPECT_NE(svgDefs, nullptr);
2012
2013 auto svgPattern = AceType::DynamicCast<SvgPattern>(svgDefs->children_.at(0));
2014 EXPECT_NE(svgPattern, nullptr);
2015 auto patternDeclaration = svgPattern->patternAttr_;
2016
2017 Testing::MockCanvas rSCanvas;
2018 EXPECT_CALL(rSCanvas, AttachBrush(_)).WillRepeatedly(ReturnRef(rSCanvas));
2019 EXPECT_CALL(rSCanvas, DetachBrush()).WillRepeatedly(ReturnRef(rSCanvas));
2020 EXPECT_CALL(rSCanvas, AttachPen(_)).WillRepeatedly(ReturnRef(rSCanvas));
2021 EXPECT_CALL(rSCanvas, DetachPen()).WillRepeatedly(ReturnRef(rSCanvas));
2022
2023 int32_t settingApiVersion = static_cast<int32_t>(PlatformVersion::VERSION_FOURTEEN);
2024 int32_t backupApiVersion = MockContainer::Current()->GetApiTargetVersion();
2025 MockContainer::Current()->SetApiTargetVersion(settingApiVersion);
2026
2027 svgPattern->OnDrawTraversedBefore(rSCanvas, Size(IMAGE_COMPONENT_WIDTH, IMAGE_COMPONENT_HEIGHT), Color::BLACK);
2028
2029 MockContainer::Current()->SetApiTargetVersion(backupApiVersion);
2030
2031 svgPattern->ParseAndSetSpecializedAttr("viewbox", "");
2032 svgPattern->ParseAndSetSpecializedAttr("viewbox", "0 0 24");
2033 EXPECT_EQ(patternDeclaration.viewBox.Width(), 10.0);
2034 EXPECT_EQ(patternDeclaration.viewBox.Height(), 10.0);
2035 }
2036
2037 /**
2038 * @tc.name: ParseFilterTest001
2039 * @tc.desc: parse Filter label
2040 * @tc.type: FUNC
2041 */
2042 HWTEST_F(ParseTestTwoNg, ParseFilterTest001, TestSize.Level1)
2043 {
2044 auto svgStream = SkMemoryStream::MakeCopy(COMPOSITE_SVG_LABEL.c_str(), COMPOSITE_SVG_LABEL.length());
2045 EXPECT_NE(svgStream, nullptr);
2046
2047 ImageSourceInfo src;
2048 src.SetFillColor(Color::BLACK);
2049
2050 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
2051 EXPECT_NE(svgDom, nullptr);
2052
2053 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
2054 EXPECT_NE(svg, nullptr);
2055 EXPECT_GT(svg->children_.size(), 0);
2056
2057 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
2058 EXPECT_NE(svgFilter, nullptr);
2059
2060 auto svgFeComposite = AceType::DynamicCast<SvgFeComposite>(svgFilter->children_.at(0));
2061 EXPECT_NE(svgFeComposite, nullptr);
2062
2063 svgFilter->filterAttr_.height = Dimension(1.0, DimensionUnit::PX);
2064 svgFilter->filterAttr_.width = Dimension(1.0, DimensionUnit::PX);
2065 svgFilter->filterAttr_.x = Dimension(1.0, DimensionUnit::PX);
2066 svgFilter->filterAttr_.y = Dimension(1.0, DimensionUnit::PX);
2067 svgFilter->OnAsPaint();
2068 EXPECT_EQ(svgFeComposite->effectFilterArea_.x_, 1.0);
2069 EXPECT_EQ(svgFeComposite->effectFilterArea_.y_, 1.0);
2070 EXPECT_EQ(svgFeComposite->effectFilterArea_.width_, 1.0);
2071 EXPECT_EQ(svgFeComposite->effectFilterArea_.height_, 1.0);
2072
2073 svgFilter->filterAttr_.height = Dimension(1.0, DimensionUnit::PERCENT);
2074 svgFilter->filterAttr_.width = Dimension(1.0, DimensionUnit::PERCENT);
2075 svgFilter->filterAttr_.x = Dimension(1.0, DimensionUnit::PERCENT);
2076 svgFilter->filterAttr_.y = Dimension(1.0, DimensionUnit::PERCENT);
2077 svgFilter->OnAsPaint();
2078 EXPECT_EQ(svgFeComposite->effectFilterArea_.x_, 0);
2079 EXPECT_EQ(svgFeComposite->effectFilterArea_.y_, 0);
2080 EXPECT_EQ(svgFeComposite->effectFilterArea_.width_, 0);
2081 EXPECT_EQ(svgFeComposite->effectFilterArea_.height_, 0);
2082 }
2083
2084 /**
2085 * @tc.name: ParseFilterTest002
2086 * @tc.desc: parse Filter label
2087 * @tc.type: FUNC
2088 */
2089 HWTEST_F(ParseTestTwoNg, ParseFilterTest002, TestSize.Level1)
2090 {
2091 auto svgStream = SkMemoryStream::MakeCopy(FE_COLOR_MATRIX.c_str(), FE_COLOR_MATRIX.length());
2092 EXPECT_NE(svgStream, nullptr);
2093
2094 ImageSourceInfo src;
2095 src.SetFillColor(Color::BLACK);
2096
2097 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
2098 EXPECT_NE(svgDom, nullptr);
2099
2100 auto svg = AceType::DynamicCast<SvgSvg>(svgDom->root_);
2101 EXPECT_NE(svg, nullptr);
2102 EXPECT_GT(svg->children_.size(), 0);
2103
2104 auto svgFilter = AceType::DynamicCast<SvgFilter>(svg->children_.at(0));
2105 EXPECT_NE(svgFilter, nullptr);
2106
2107 svgFilter->children_.at(0) = nullptr;
2108 svgFilter->OnAsPaint();
2109 auto nodeFe1 = AceType::DynamicCast<SvgFe>(svgFilter->children_.at(0));
2110 auto nodeFe2 = AceType::DynamicCast<SvgFe>(svgFilter->children_.at(1));
2111 EXPECT_EQ(nodeFe1, nullptr);
2112 EXPECT_NE(nodeFe2, nullptr);
2113 }
2114
2115 /**
2116 * @tc.name: ParseNodeTest006
2117 * @tc.desc: Test SvgNode SetAttr Parameters
2118 * @tc.type: FUNC
2119 */
2120 HWTEST_F(ParseTestTwoNg, ParseNodeTest006, TestSize.Level1)
2121 {
2122 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
2123 svgNode->SetAttr("fill", "url(#test)");
2124 EXPECT_EQ(svgNode->GetBaseAttributes().fillState.GetHref(), "test");
2125
2126 int32_t settingApiVersion = static_cast<int32_t>(PlatformVersion::VERSION_FOURTEEN);
2127 int32_t backupApiVersion = MockContainer::Current()->GetApiTargetVersion();
2128 MockContainer::Current()->SetApiTargetVersion(settingApiVersion);
2129
2130 svgNode->SetAttr("stroke", "#test");
2131
2132 MockContainer::Current()->SetApiTargetVersion(backupApiVersion);
2133
2134 svgNode->SetAttr("stroke", "url(#test)");
2135
2136 svgNode->InitStyle(SvgBaseAttribute());
2137 EXPECT_EQ(svgNode->GetBaseAttributes().strokeState.GetHref(), "test");
2138 }
2139
2140 /**
2141 * @tc.name: ParseNodeTest007
2142 * @tc.desc: Test SvgNode SetAttr Parameters
2143 * @tc.type: FUNC
2144 */
2145 HWTEST_F(ParseTestTwoNg, ParseNodeTest007, TestSize.Level1)
2146 {
2147 auto svgStream = SkMemoryStream::MakeCopy(GRADIENT_SVG_LINEAR.c_str(), GRADIENT_SVG_LINEAR.length());
2148 EXPECT_NE(svgStream, nullptr);
2149
2150 ImageSourceInfo src;
2151 src.SetFillColor(Color::BLACK);
2152
2153 auto svgDom = SvgDom::CreateSvgDom(*svgStream, src);
2154 EXPECT_NE(svgDom, nullptr);
2155
2156 svgDom->root_->SetAttr("fill", "url(#grad1)");
2157 svgDom->root_->SetAttr("stroke", "url(#grad1)");
2158 svgDom->root_->InitStyle(SvgBaseAttribute());
2159 EXPECT_EQ(svgDom->root_->GetBaseAttributes().strokeState.GetHref(), "grad1");
2160 EXPECT_EQ(svgDom->root_->GetBaseAttributes().fillState.GetHref(), "grad1");
2161 }
2162
2163 /**
2164 * @tc.name: ParseStyleTest001
2165 * @tc.desc: parse use label
2166 * @tc.type: FUNC
2167 */
2168 HWTEST_F(ParseTestTwoNg, ParseStyleTest001, TestSize.Level1)
2169 {
2170 /* *
2171 * @tc.steps: step1. call ParseCssStyle
2172 * @tc.expected: Execute function return value false
2173 */
2174 std::string str;
__anona52951970602(const std::string& key, const std::pair<std::string, std::string>& value) 2175 PushAttr callback = [&str](const std::string& key, const std::pair<std::string, std::string>& value) { str = key; };
2176 SvgStyle::ParseCssStyle("", callback);
2177 EXPECT_TRUE(str.empty());
2178
2179 SvgStyle::ParseCssStyle("body {font-style: oblique;}.normal {font-style: normal;}", callback);
2180 EXPECT_FALSE(str.empty());
2181 }
2182
2183 /**
2184 * @tc.name: ParseStyleTest001
2185 * @tc.desc: parse use label
2186 * @tc.type: FUNC
2187 */
2188 HWTEST_F(ParseTestTwoNg, SvgTransform001, TestSize.Level1)
2189 {
2190 // NG::NGSvgTransform::ApplyTransformPivot
2191 std::vector<NG::TransformInfo> transformVec;
2192 NG::TransformInfo info;
2193 std::vector<std::string> paramVec;
2194 info.funcType = "asd";
2195 paramVec.emplace_back("213");
2196 paramVec.emplace_back("21333");
2197 info.paramVec = paramVec;
2198 transformVec.emplace_back(info);
2199
2200 NG::TransformInfo info1;
2201 std::vector<std::string> paramVec1;
2202 info1.funcType = "asd";
2203 paramVec1.emplace_back("213");
2204 paramVec1.emplace_back("21333");
2205 info1.paramVec = paramVec1;
2206 transformVec.emplace_back(info1);
2207
2208 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
2209 Rect containerRect(0, 0, 1, 1);
2210 Size viewPort(1, 1);
2211 SvgCoordinateSystemContext context(containerRect, viewPort);
2212 auto rule = svgNode->BuildContentScaleRule(context, OHOS::Ace::NG::SvgLengthScaleUnit::USER_SPACE_ON_USE);
2213 EXPECT_EQ(rule.GetLengthScaleUnit(), OHOS::Ace::NG::SvgLengthScaleUnit::USER_SPACE_ON_USE);
2214 Offset offset;
2215 auto result = NGSvgTransform::CreateMatrix4(transformVec, offset, rule);
2216 EXPECT_EQ(result.Get(1, 0), 0);
2217 }
2218
2219 /**
2220 * @tc.name: ParseStyleTest001
2221 * @tc.desc: parse use label
2222 * @tc.type: FUNC
2223 */
2224 HWTEST_F(ParseTestTwoNg, SvgTransform002, TestSize.Level1)
2225 {
2226 // NG::NGSvgTransform::ApplyTransformPivot
2227 std::vector<NG::TransformInfo> transformVec;
2228 NG::TransformInfo info;
2229 std::vector<std::string> paramVec;
2230 info.funcType = "matrix";
2231 paramVec.emplace_back("213");
2232 paramVec.emplace_back("21333");
2233 info.paramVec = paramVec;
2234 transformVec.emplace_back(info);
2235
2236 NG::TransformInfo info1;
2237 std::vector<std::string> paramVec1;
2238 info1.funcType = "matrix";
2239 paramVec1.emplace_back("213");
2240 paramVec1.emplace_back("21333");
2241 paramVec1.emplace_back("215333");
2242 paramVec1.emplace_back("213733");
2243 paramVec1.emplace_back("213363");
2244 paramVec1.emplace_back("217333");
2245 info1.paramVec = paramVec1;
2246 transformVec.emplace_back(info1);
2247
2248 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
2249 Rect containerRect(0, 0, 1, 1);
2250 Size viewPort(1, 1);
2251 SvgCoordinateSystemContext context(containerRect, viewPort);
2252 auto rule = svgNode->BuildContentScaleRule(context, OHOS::Ace::NG::SvgLengthScaleUnit::USER_SPACE_ON_USE);
2253 EXPECT_EQ(rule.GetLengthScaleUnit(), OHOS::Ace::NG::SvgLengthScaleUnit::USER_SPACE_ON_USE);
2254 Offset offset;
2255 auto result = NGSvgTransform::CreateMatrix4(transformVec, offset, rule);
2256 EXPECT_EQ(result.Get(1, 0), 0);
2257 }
2258
2259 /**
2260 * @tc.name: ParseStyleTest001
2261 * @tc.desc: parse use label
2262 * @tc.type: FUNC
2263 */
2264 HWTEST_F(ParseTestTwoNg, SvgTransform003, TestSize.Level1)
2265 {
2266 // NG::NGSvgTransform::ApplyTransformPivot
2267 std::vector<NG::TransformInfo> transformVec;
2268 NG::TransformInfo info;
2269 std::vector<std::string> paramVec;
2270 info.funcType = "rotate";
2271 paramVec.emplace_back("21333");
2272 info.paramVec = paramVec;
2273 transformVec.emplace_back(info);
2274
2275 NG::TransformInfo info1;
2276 std::vector<std::string> paramVec1;
2277 info1.funcType = "rotate";
2278 paramVec1.emplace_back("213");
2279 paramVec1.emplace_back("21333");
2280 paramVec1.emplace_back("215333");
2281 paramVec1.emplace_back("213733");
2282 paramVec1.emplace_back("213363");
2283 paramVec1.emplace_back("217333");
2284 info1.paramVec = paramVec1;
2285 transformVec.emplace_back(info1);
2286
2287 NG::TransformInfo info2;
2288 std::vector<std::string> paramVec2;
2289 info2.funcType = "rotate";
2290 paramVec2.emplace_back("213");
2291 paramVec2.emplace_back("21333");
2292 paramVec2.emplace_back("215333");
2293 info2.paramVec = paramVec2;
2294 transformVec.emplace_back(info2);
2295
2296 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
2297 Rect containerRect(0, 0, 1, 1);
2298 Size viewPort(1, 1);
2299 SvgCoordinateSystemContext context(containerRect, viewPort);
2300 auto rule = svgNode->BuildContentScaleRule(context, OHOS::Ace::NG::SvgLengthScaleUnit::USER_SPACE_ON_USE);
2301 EXPECT_EQ(rule.GetLengthScaleUnit(), OHOS::Ace::NG::SvgLengthScaleUnit::USER_SPACE_ON_USE);
2302 Offset offset;
2303 auto result = NGSvgTransform::CreateMatrix4(transformVec, offset, rule);
2304 EXPECT_EQ(result.Get(1, 0), 0);
2305 }
2306
2307 /**
2308 * @tc.name: ParseStyleTest001
2309 * @tc.desc: parse use label
2310 * @tc.type: FUNC
2311 */
2312 HWTEST_F(ParseTestTwoNg, SvgTransform004, TestSize.Level1)
2313 {
2314 // NG::NGSvgTransform::ApplyTransformPivot
2315 std::vector<NG::TransformInfo> transformVec;
2316 NG::TransformInfo info;
2317 std::vector<std::string> paramVec;
2318 info.funcType = "scale";
2319 paramVec.emplace_back("213");
2320 info.paramVec = paramVec;
2321 transformVec.emplace_back(info);
2322
2323 NG::TransformInfo info1;
2324 std::vector<std::string> paramVec1;
2325 info1.funcType = "scale";
2326 paramVec1.emplace_back("213");
2327 paramVec1.emplace_back("21333");
2328 info1.paramVec = paramVec1;
2329 transformVec.emplace_back(info1);
2330
2331 NG::TransformInfo info2;
2332 std::vector<std::string> paramVec2;
2333 info2.funcType = "scale";
2334 paramVec2.emplace_back("213");
2335 paramVec2.emplace_back("21333");
2336 paramVec2.emplace_back("215333");
2337 info2.paramVec = paramVec2;
2338 transformVec.emplace_back(info2);
2339
2340 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
2341 Rect containerRect(0, 0, 1, 1);
2342 Size viewPort(1, 1);
2343 SvgCoordinateSystemContext context(containerRect, viewPort);
2344 auto rule = svgNode->BuildContentScaleRule(context, OHOS::Ace::NG::SvgLengthScaleUnit::USER_SPACE_ON_USE);
2345 EXPECT_EQ(rule.GetLengthScaleUnit(), OHOS::Ace::NG::SvgLengthScaleUnit::USER_SPACE_ON_USE);
2346 Offset offset;
2347 auto result = NGSvgTransform::CreateMatrix4(transformVec, offset, rule);
2348 EXPECT_EQ(result.Get(1, 0), 0);
2349 }
2350
2351 /**
2352 * @tc.name: ParseStyleTest001
2353 * @tc.desc: parse use label
2354 * @tc.type: FUNC
2355 */
2356 HWTEST_F(ParseTestTwoNg, SvgTransform005, TestSize.Level1)
2357 {
2358 // NG::NGSvgTransform::ApplyTransformPivot
2359 std::vector<NG::TransformInfo> transformVec;
2360 NG::TransformInfo info;
2361 std::vector<std::string> paramVec;
2362 info.funcType = "skewX";
2363 paramVec.emplace_back("21333");
2364 info.paramVec = paramVec;
2365 transformVec.emplace_back(info);
2366
2367 NG::TransformInfo info1;
2368 std::vector<std::string> paramVec1;
2369 info1.funcType = "skewX";
2370 paramVec1.emplace_back("213");
2371 paramVec1.emplace_back("21333");
2372 paramVec1.emplace_back("215333");
2373 paramVec1.emplace_back("213733");
2374 paramVec1.emplace_back("213363");
2375 paramVec1.emplace_back("217333");
2376 info1.paramVec = paramVec1;
2377 transformVec.emplace_back(info1);
2378
2379 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
2380 Rect containerRect(0, 0, 1, 1);
2381 Size viewPort(1, 1);
2382 SvgCoordinateSystemContext context(containerRect, viewPort);
2383 auto rule = svgNode->BuildContentScaleRule(context, OHOS::Ace::NG::SvgLengthScaleUnit::USER_SPACE_ON_USE);
2384 EXPECT_EQ(rule.GetLengthScaleUnit(), OHOS::Ace::NG::SvgLengthScaleUnit::USER_SPACE_ON_USE);
2385 Offset offset;
2386 auto result = NGSvgTransform::CreateMatrix4(transformVec, offset, rule);
2387 EXPECT_EQ(result.Get(1, 0), 0);
2388 }
2389
2390 /**
2391 * @tc.name: ParseStyleTest001
2392 * @tc.desc: parse use label
2393 * @tc.type: FUNC
2394 */
2395 HWTEST_F(ParseTestTwoNg, SvgTransform006, TestSize.Level1)
2396 {
2397 // NG::NGSvgTransform::ApplyTransformPivot
2398 std::vector<NG::TransformInfo> transformVec;
2399 NG::TransformInfo info;
2400 std::vector<std::string> paramVec;
2401 info.funcType = "skewY";
2402 paramVec.emplace_back("21333");
2403 info.paramVec = paramVec;
2404 transformVec.emplace_back(info);
2405
2406 NG::TransformInfo info1;
2407 std::vector<std::string> paramVec1;
2408 info1.funcType = "skewY";
2409 paramVec1.emplace_back("213");
2410 paramVec1.emplace_back("21333");
2411 paramVec1.emplace_back("215333");
2412 paramVec1.emplace_back("213733");
2413 paramVec1.emplace_back("213363");
2414 paramVec1.emplace_back("217333");
2415 info1.paramVec = paramVec1;
2416 transformVec.emplace_back(info1);
2417
2418 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
2419 Rect containerRect(0, 0, 1, 1);
2420 Size viewPort(1, 1);
2421 SvgCoordinateSystemContext context(containerRect, viewPort);
2422 auto rule = svgNode->BuildContentScaleRule(context, OHOS::Ace::NG::SvgLengthScaleUnit::USER_SPACE_ON_USE);
2423 EXPECT_EQ(rule.GetLengthScaleUnit(), OHOS::Ace::NG::SvgLengthScaleUnit::USER_SPACE_ON_USE);
2424 Offset offset;
2425 auto result = NGSvgTransform::CreateMatrix4(transformVec, offset, rule);
2426 EXPECT_EQ(result.Get(1, 0), 0);
2427 }
2428
2429 /**
2430 * @tc.name: ParseStyleTest001
2431 * @tc.desc: parse use label
2432 * @tc.type: FUNC
2433 */
2434 HWTEST_F(ParseTestTwoNg, SvgTransform007, TestSize.Level1)
2435 {
2436 // NG::NGSvgTransform::ApplyTransformPivot
2437 std::vector<NG::TransformInfo> transformVec;
2438 NG::TransformInfo info;
2439 std::vector<std::string> paramVec;
2440 info.funcType = "translate";
2441 paramVec.emplace_back("21333");
2442 info.paramVec = paramVec;
2443 transformVec.emplace_back(info);
2444
2445 NG::TransformInfo info1;
2446 std::vector<std::string> paramVec1;
2447 info1.funcType = "translate";
2448 paramVec1.emplace_back("213");
2449 paramVec1.emplace_back("21333");
2450 paramVec1.emplace_back("215333");
2451 paramVec1.emplace_back("213733");
2452 paramVec1.emplace_back("213363");
2453 paramVec1.emplace_back("217333");
2454 info1.paramVec = paramVec1;
2455 transformVec.emplace_back(info1);
2456
2457 NG::TransformInfo info2;
2458 std::vector<std::string> paramVec2;
2459 info2.funcType = "translate";
2460 paramVec2.emplace_back("213");
2461 paramVec2.emplace_back("21333");
2462 paramVec2.emplace_back("215333");
2463 info2.paramVec = paramVec2;
2464 transformVec.emplace_back(info2);
2465
2466 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
2467 Rect containerRect(0, 0, 1, 1);
2468 Size viewPort(1, 1);
2469 SvgCoordinateSystemContext context(containerRect, viewPort);
2470 auto rule = svgNode->BuildContentScaleRule(context, OHOS::Ace::NG::SvgLengthScaleUnit::USER_SPACE_ON_USE);
2471 EXPECT_EQ(rule.GetLengthScaleUnit(), OHOS::Ace::NG::SvgLengthScaleUnit::USER_SPACE_ON_USE);
2472 Offset offset;
2473 auto result = NGSvgTransform::CreateMatrix4(transformVec, offset, rule);
2474 EXPECT_EQ(result.Get(1, 0), 0);
2475 }
2476
2477 /**
2478 * @tc.name: ParseStyleTest001
2479 * @tc.desc: parse use label
2480 * @tc.type: FUNC
2481 */
2482 HWTEST_F(ParseTestTwoNg, SvgTransform008, TestSize.Level1)
2483 {
2484 std::vector<std::string> paramVec;
2485 RSMatrix matrix;
2486
2487 auto result = NGSvgTransform::CreateTranslate(paramVec, matrix);
2488 EXPECT_FALSE(result);
2489 paramVec.emplace_back("2153353");
2490 result = NGSvgTransform::CreateTranslate(paramVec, matrix);
2491 EXPECT_TRUE(result);
2492
2493 paramVec.emplace_back("21533333");
2494 result = NGSvgTransform::CreateTranslate(paramVec, matrix);
2495 EXPECT_TRUE(result);
2496
2497 paramVec.emplace_back("21536633");
2498 result = NGSvgTransform::CreateTranslate(paramVec, matrix);
2499 EXPECT_FALSE(result);
2500
2501 paramVec.emplace_back("2153600633");
2502 result = NGSvgTransform::CreateTranslate(paramVec, matrix);
2503 EXPECT_FALSE(result);
2504 }
2505
2506 /**
2507 * @tc.name: ParseStyleTest001
2508 * @tc.desc: parse use label
2509 * @tc.type: FUNC
2510 */
2511 HWTEST_F(ParseTestTwoNg, SvgTransform009, TestSize.Level1)
2512 {
2513 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
2514 Rect containerRect(0, 0, 1, 1);
2515 Size viewPort(1, 1);
2516 SvgCoordinateSystemContext context(containerRect, viewPort);
2517 auto rule = svgNode->BuildContentScaleRule(context, OHOS::Ace::NG::SvgLengthScaleUnit::USER_SPACE_ON_USE);
2518 EXPECT_EQ(rule.GetLengthScaleUnit(), OHOS::Ace::NG::SvgLengthScaleUnit::USER_SPACE_ON_USE);
2519 std::vector<std::string> paramVec;
2520 Matrix4 matrix;
2521
2522 std::string funcType = "asd";
2523 auto result = NGSvgTransform::UpdateSingleTransform(funcType, paramVec, matrix, rule);
2524 EXPECT_FALSE(result);
2525
2526 funcType = "matrix";
2527 result = NGSvgTransform::UpdateSingleTransform(funcType, paramVec, matrix, rule);
2528 EXPECT_FALSE(result);
2529
2530 funcType = "matrix";
2531 paramVec.clear();
2532 paramVec.emplace_back("1");
2533 paramVec.emplace_back("2");
2534 paramVec.emplace_back("3");
2535 paramVec.emplace_back("4");
2536 paramVec.emplace_back("5");
2537 paramVec.emplace_back("6");
2538 result = NGSvgTransform::UpdateSingleTransform(funcType, paramVec, matrix, rule);
2539 EXPECT_TRUE(result);
2540
2541 funcType = "rotate";
2542 paramVec.clear();
2543 result = NGSvgTransform::UpdateSingleTransform(funcType, paramVec, matrix, rule);
2544 EXPECT_FALSE(result);
2545
2546 funcType = "rotate";
2547 paramVec.clear();
2548 paramVec.emplace_back("1");
2549 result = NGSvgTransform::UpdateSingleTransform(funcType, paramVec, matrix, rule);
2550 EXPECT_TRUE(result);
2551
2552 funcType = "scale";
2553 paramVec.clear();
2554 result = NGSvgTransform::UpdateSingleTransform(funcType, paramVec, matrix, rule);
2555 EXPECT_FALSE(result);
2556
2557 funcType = "scale";
2558 paramVec.clear();
2559 paramVec.emplace_back("1");
2560 result = NGSvgTransform::UpdateSingleTransform(funcType, paramVec, matrix, rule);
2561 EXPECT_TRUE(result);
2562
2563 funcType = "scale";
2564 paramVec.clear();
2565 paramVec.emplace_back("1");
2566 paramVec.emplace_back("2");
2567 result = NGSvgTransform::UpdateSingleTransform(funcType, paramVec, matrix, rule);
2568 EXPECT_TRUE(result);
2569 }
2570
2571 /**
2572 * @tc.name: ParseStyleTest001
2573 * @tc.desc: parse use label
2574 * @tc.type: FUNC
2575 */
2576 HWTEST_F(ParseTestTwoNg, SvgTransform010, TestSize.Level1)
2577 {
2578 auto svgNode = AccessibilityManager::MakeRefPtr<SvgNode>();
2579 Rect containerRect(0, 0, 1, 1);
2580 Size viewPort(1, 1);
2581 SvgCoordinateSystemContext context(containerRect, viewPort);
2582 auto rule = svgNode->BuildContentScaleRule(context, OHOS::Ace::NG::SvgLengthScaleUnit::USER_SPACE_ON_USE);
2583 EXPECT_EQ(rule.GetLengthScaleUnit(), OHOS::Ace::NG::SvgLengthScaleUnit::USER_SPACE_ON_USE);
2584 std::vector<std::string> paramVec;
2585 Matrix4 matrix;
2586 std::string funcType = "asd";
2587
2588 funcType = "skewX";
2589 paramVec.clear();
2590 auto result = NGSvgTransform::UpdateSingleTransform(funcType, paramVec, matrix, rule);
2591 EXPECT_FALSE(result);
2592
2593 funcType = "skewX";
2594 paramVec.clear();
2595 paramVec.emplace_back("1");
2596 result = NGSvgTransform::UpdateSingleTransform(funcType, paramVec, matrix, rule);
2597 EXPECT_TRUE(result);
2598
2599 funcType = "skewY";
2600 paramVec.clear();
2601 result = NGSvgTransform::UpdateSingleTransform(funcType, paramVec, matrix, rule);
2602 EXPECT_FALSE(result);
2603
2604 funcType = "skewY";
2605 paramVec.clear();
2606 paramVec.emplace_back("1");
2607 result = NGSvgTransform::UpdateSingleTransform(funcType, paramVec, matrix, rule);
2608 EXPECT_TRUE(result);
2609
2610 funcType = "translate";
2611 paramVec.clear();
2612 result = NGSvgTransform::UpdateSingleTransform(funcType, paramVec, matrix, rule);
2613 EXPECT_FALSE(result);
2614
2615 funcType = "translate";
2616 paramVec.clear();
2617 paramVec.emplace_back("1");
2618 result = NGSvgTransform::UpdateSingleTransform(funcType, paramVec, matrix, rule);
2619 EXPECT_TRUE(result);
2620
2621 funcType = "translate";
2622 paramVec.clear();
2623 paramVec.emplace_back("1");
2624 paramVec.emplace_back("2");
2625 result = NGSvgTransform::UpdateSingleTransform(funcType, paramVec, matrix, rule);
2626 EXPECT_TRUE(result);
2627 }
2628
2629 /**
2630 * @tc.name: ParseStyleTest001
2631 * @tc.desc: parse use label
2632 * @tc.type: FUNC
2633 */
2634 HWTEST_F(ParseTestTwoNg, SvgTransform011, TestSize.Level1)
2635 {
2636 Matrix4 matrix;
2637 Offset offset;
2638 std::string funcType = "asd";
2639 NGSvgTransform::ApplyTransformPivot(funcType, offset, matrix);
2640 EXPECT_EQ(funcType, "asd");
2641 }
2642
2643 /**
2644 * @tc.name: ParseStyleTest001
2645 * @tc.desc: parse use label
2646 * @tc.type: FUNC
2647 */
2648 HWTEST_F(ParseTestTwoNg, SvgClipPath001, TestSize.Level1)
2649 {
2650 auto clipPath = AceType::DynamicCast<SvgClipPath>(SvgClipPath::Create());
2651 EXPECT_NE(clipPath, nullptr);
2652
2653 Testing::MockCanvas rSCanvas;
2654 Rect rect(10, 12, 13, 15);
2655 Size size(10, 10);
2656 SvgCoordinateSystemContext context(rect, size);
2657
2658 clipPath->OnClipEffect(rSCanvas, context);
2659 auto svgContext = AceType::MakeRefPtr<SvgContext>();
2660 clipPath->SetContext(svgContext);
2661 clipPath->OnClipEffect(rSCanvas, context);
2662
2663 SvgLengthScaleRule clipPathRule = context.BuildScaleRule(clipPath->attributes_.clipState.GetClipPathUnits());
2664 auto result = clipPath->AsPath(clipPathRule);
2665 EXPECT_TRUE(result.BuildFromSVGString(""));
2666 }
2667 } // namespace OHOS::Ace::NG
2668