1 #if LV_BUILD_TEST
2 #include "../lvgl.h"
3
4 #include "unity/unity.h"
5
6 #define LV_ARRAY_GET(array, index, type) ((type*)lv_array_at((array), (index)))
7
8 static const char * svg_str_1 = \
9 "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>"
10 "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">"
11 "<!-- some comment content <tag> <desc> ... -->"
12 "<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.2\" baseProfile=\"tiny\""
13 "width=\"300px\" height=\"600px\" viewBox =\"0 0 10 10\">"
14 "<rect xml:id=rect1 fill=\"white\" x=\"10\" y=\"10\" width=\"100\" height=\"100\"/>"
15 "<desc> SVG Test </desc>"
16 "</svg>";
17
setUp(void)18 void setUp(void)
19 {
20 }
21
tearDown(void)22 void tearDown(void)
23 {
24 }
25
testSvgParser(void)26 void testSvgParser(void)
27 {
28 lv_svg_node_t * svg = lv_svg_load_data(svg_str_1, lv_strlen(svg_str_1));
29 TEST_ASSERT_NOT_EQUAL(NULL, svg);
30 lv_svg_node_delete(svg);
31 }
32
testNode(void)33 void testNode(void)
34 {
35 lv_svg_node_t * svg = lv_svg_node_create(NULL);
36
37 TEST_ASSERT_NOT_EQUAL(NULL, svg);
38 lv_svg_node_delete(svg);
39 }
40
testNodeTree(void)41 void testNodeTree(void)
42 {
43 lv_svg_node_t * root = lv_svg_node_create(NULL);
44
45 lv_svg_node_t * node1 = lv_svg_node_create(root);
46 lv_svg_node_t * node2 = lv_svg_node_create(node1);
47 lv_svg_node_t * node3 = lv_svg_node_create(root);
48
49 lv_svg_attr_t attr1;
50 attr1.id = LV_SVG_ATTR_X;
51 attr1.val_type = LV_SVG_ATTR_VALUE_DATA;
52 attr1.value.fval = 10.0f;
53
54 lv_array_push_back(&node3->attrs, &attr1);
55
56 TEST_ASSERT_EQUAL(lv_array_size(&node3->attrs), 1);
57 TEST_ASSERT_EQUAL_FLOAT((LV_ARRAY_GET(&node3->attrs, 0, lv_svg_attr_t))->value.fval, 10.0f);
58
59 lv_svg_node_delete(node2);
60 lv_svg_node_delete(root);
61 }
62
testSvgElement(void)63 void testSvgElement(void)
64 {
65 const char * svg_1 = \
66 "<svg version=\"1.2\" baseProfile=\"tiny\"></svg>";
67 lv_svg_node_t * svg_node1 = lv_svg_load_data(svg_1, lv_strlen(svg_1));
68 TEST_ASSERT_EQUAL(lv_array_size(&svg_node1->attrs), 2);
69 TEST_ASSERT_EQUAL_STRING((LV_ARRAY_GET(&svg_node1->attrs, 0, lv_svg_attr_t))->value.sval, "1.2");
70 TEST_ASSERT_EQUAL_STRING((LV_ARRAY_GET(&svg_node1->attrs, 1, lv_svg_attr_t))->value.sval, "tiny");
71 lv_svg_node_delete(svg_node1);
72
73 /* test viewBox */
74 const char * svg_viewbox0 = \
75 "<svg viewBox=\"none\"></svg>";
76 lv_svg_node_t * svg_node_viewbox = lv_svg_load_data(svg_viewbox0, lv_strlen(svg_viewbox0));
77 TEST_ASSERT_EQUAL(0, LV_ARRAY_GET(&svg_node_viewbox->attrs, 0, lv_svg_attr_t)->class_type);
78 lv_svg_node_delete(svg_node_viewbox);
79
80 const char * svg_viewbox1 = \
81 "<svg viewBox=\"0 0 10 10\"></svg>";
82 lv_svg_node_t * svg_node_viewbox1 = lv_svg_load_data(svg_viewbox1, lv_strlen(svg_viewbox1));
83 float ret1[4] = {0.0f, 0.0f, 10.0f, 10.0f};
84 TEST_ASSERT_EQUAL_FLOAT_ARRAY(ret1, (float *)(LV_ARRAY_GET(&svg_node_viewbox1->attrs, 0, lv_svg_attr_t))->value.val, 4);
85 lv_svg_node_delete(svg_node_viewbox1);
86
87 const char * svg_viewbox2 = \
88 "<svg viewBox=\"-5,10 +10,-10\"></svg>";
89 lv_svg_node_t * svg_node_viewbox2 = lv_svg_load_data(svg_viewbox2, lv_strlen(svg_viewbox2));
90 float ret2[4] = {-5.0f, 10.0f, 10.0f, -10.0f};
91 TEST_ASSERT_EQUAL_FLOAT_ARRAY(ret2, (float *)(LV_ARRAY_GET(&svg_node_viewbox2->attrs, 0, lv_svg_attr_t))->value.val, 4);
92 lv_svg_node_delete(svg_node_viewbox2);
93
94 const char * svg_viewbox3 = \
95 "<svg viewBox=\"-5,-5\"></svg>";
96 lv_svg_node_t * svg_node_viewbox3 = lv_svg_load_data(svg_viewbox3, lv_strlen(svg_viewbox3));
97 TEST_ASSERT_EQUAL(0, LV_ARRAY_GET(&svg_node_viewbox3->attrs, 0, lv_svg_attr_t)->class_type);
98 lv_svg_node_delete(svg_node_viewbox3);
99
100 const char * svg_viewbox4 = \
101 "<svg viewBox=\"-5,-5 .2 1.5E+1\"></svg>";
102 lv_svg_node_t * svg_node_viewbox4 = lv_svg_load_data(svg_viewbox4, lv_strlen(svg_viewbox4));
103 float ret4[4] = {-5.0f, -5.0f, 0.2f, 15.0f};
104 TEST_ASSERT_EQUAL_FLOAT_ARRAY(ret4, (float *)(LV_ARRAY_GET(&svg_node_viewbox4->attrs, 0, lv_svg_attr_t))->value.val, 4);
105 lv_svg_node_delete(svg_node_viewbox4);
106
107 /* width and height */
108 const char * svg_wh = \
109 "<svg width=\"100\" height=\"100px\"></svg>";
110 lv_svg_node_t * svg_node_wh = lv_svg_load_data(svg_wh, lv_strlen(svg_wh));
111 TEST_ASSERT_EQUAL_FLOAT((LV_ARRAY_GET(&svg_node_wh->attrs, 0, lv_svg_attr_t))->value.fval, 100.0f);
112 TEST_ASSERT_EQUAL_FLOAT((LV_ARRAY_GET(&svg_node_wh->attrs, 1, lv_svg_attr_t))->value.fval, 100.0f);
113 lv_svg_node_delete(svg_node_wh);
114
115 const char * svg_wh2 = \
116 "<svg width=\"10cm\" height=\"100mm\"></svg>";
117 lv_svg_node_t * svg_node_wh2 = lv_svg_load_data(svg_wh2, lv_strlen(svg_wh2));
118 TEST_ASSERT_EQUAL_FLOAT((LV_ARRAY_GET(&svg_node_wh2->attrs, 0, lv_svg_attr_t))->value.fval, 377.9528f);
119 TEST_ASSERT_EQUAL_FLOAT((LV_ARRAY_GET(&svg_node_wh2->attrs, 1, lv_svg_attr_t))->value.fval, 377.9528f);
120 lv_svg_node_delete(svg_node_wh2);
121
122 const char * svg_wh3 = \
123 "<svg width=\"10in\" height=\"10pc\"></svg>";
124 lv_svg_node_t * svg_node_wh3 = lv_svg_load_data(svg_wh3, lv_strlen(svg_wh3));
125 TEST_ASSERT_EQUAL_FLOAT((LV_ARRAY_GET(&svg_node_wh3->attrs, 0, lv_svg_attr_t))->value.fval, 960.0f);
126 TEST_ASSERT_EQUAL_FLOAT((LV_ARRAY_GET(&svg_node_wh3->attrs, 1, lv_svg_attr_t))->value.fval, 160.0f);
127 lv_svg_node_delete(svg_node_wh3);
128
129 const char * svg_wh4 = \
130 "<svg width=\"10em\" height=\"10ex\"></svg>";
131 lv_svg_node_t * svg_node_wh4 = lv_svg_load_data(svg_wh4, lv_strlen(svg_wh4));
132 TEST_ASSERT_EQUAL_FLOAT((LV_ARRAY_GET(&svg_node_wh4->attrs, 0, lv_svg_attr_t))->value.fval, 160.0f);
133 TEST_ASSERT_EQUAL_FLOAT((LV_ARRAY_GET(&svg_node_wh4->attrs, 1, lv_svg_attr_t))->value.fval, 83.2f);
134 lv_svg_node_delete(svg_node_wh4);
135
136 const char * svg_wh5 = \
137 "<svg width=\"10pt\" height=\"100%\"></svg>";
138 lv_svg_node_t * svg_node_wh5 = lv_svg_load_data(svg_wh5, lv_strlen(svg_wh5));
139 TEST_ASSERT_EQUAL_FLOAT((LV_ARRAY_GET(&svg_node_wh5->attrs, 0, lv_svg_attr_t))->value.fval, 13.3333f);
140 TEST_ASSERT_EQUAL_FLOAT((LV_ARRAY_GET(&svg_node_wh5->attrs, 1, lv_svg_attr_t))->value.fval, 1.0f);
141 lv_svg_node_delete(svg_node_wh5);
142
143 /* preserveAspectRatio */
144
145 const char * svg_ar0 = \
146 "<svg preserveAspectRatio=\"none meet\"></svg>";
147 lv_svg_node_t * svg_node_ar = lv_svg_load_data(svg_ar0, lv_strlen(svg_ar0));
148 TEST_ASSERT_EQUAL(lv_array_size(&svg_node_ar->attrs), 1);
149 lv_svg_node_delete(svg_node_ar);
150
151 const char * svg_ar1 = \
152 "<svg preserveAspectRatio=\"xMinYMin meet\"></svg>";
153 svg_node_ar = lv_svg_load_data(svg_ar1, lv_strlen(svg_ar1));
154 TEST_ASSERT_EQUAL((LV_ARRAY_GET(&svg_node_ar->attrs, 0, lv_svg_attr_t))->value.uval, 2);
155 lv_svg_node_delete(svg_node_ar);
156
157 const char * svg_ar2 = \
158 "<svg preserveAspectRatio=\" xMidYMin slice\"></svg>";
159 svg_node_ar = lv_svg_load_data(svg_ar2, lv_strlen(svg_ar2));
160 TEST_ASSERT_EQUAL((LV_ARRAY_GET(&svg_node_ar->attrs, 0, lv_svg_attr_t))->value.uval, 5);
161 lv_svg_node_delete(svg_node_ar);
162
163 const char * svg_ar3 = \
164 "<svg preserveAspectRatio=\"xMaxYMin unknow\"></svg>";
165 svg_node_ar = lv_svg_load_data(svg_ar3, lv_strlen(svg_ar3));
166 TEST_ASSERT_EQUAL((LV_ARRAY_GET(&svg_node_ar->attrs, 0, lv_svg_attr_t))->value.uval, 6);
167 lv_svg_node_delete(svg_node_ar);
168
169 const char * svg_ar4 = \
170 "<svg preserveAspectRatio=\"xMinYMid meet\"></svg>";
171 svg_node_ar = lv_svg_load_data(svg_ar4, lv_strlen(svg_ar4));
172 TEST_ASSERT_EQUAL((LV_ARRAY_GET(&svg_node_ar->attrs, 0, lv_svg_attr_t))->value.uval, 8);
173 lv_svg_node_delete(svg_node_ar);
174
175 const char * svg_ar5 = \
176 "<svg preserveAspectRatio=\"xMidYMid\"></svg>";
177 svg_node_ar = lv_svg_load_data(svg_ar5, lv_strlen(svg_ar5));
178 TEST_ASSERT_EQUAL((LV_ARRAY_GET(&svg_node_ar->attrs, 0, lv_svg_attr_t))->value.uval, 10);
179 lv_svg_node_delete(svg_node_ar);
180
181 const char * svg_ar6 = \
182 "<svg preserveAspectRatio=\"xMaxYMid slice\"></svg>";
183 svg_node_ar = lv_svg_load_data(svg_ar6, lv_strlen(svg_ar6));
184 TEST_ASSERT_EQUAL((LV_ARRAY_GET(&svg_node_ar->attrs, 0, lv_svg_attr_t))->value.uval, 13);
185 lv_svg_node_delete(svg_node_ar);
186
187 const char * svg_ar7 = \
188 "<svg preserveAspectRatio=\"xMinYMax slice\"></svg>";
189 svg_node_ar = lv_svg_load_data(svg_ar7, lv_strlen(svg_ar7));
190 TEST_ASSERT_EQUAL((LV_ARRAY_GET(&svg_node_ar->attrs, 0, lv_svg_attr_t))->value.uval, 15);
191 lv_svg_node_delete(svg_node_ar);
192
193 const char * svg_ar8 = \
194 "<svg preserveAspectRatio=\"xMidYMax meet\"></svg>";
195 svg_node_ar = lv_svg_load_data(svg_ar8, lv_strlen(svg_ar8));
196 TEST_ASSERT_EQUAL((LV_ARRAY_GET(&svg_node_ar->attrs, 0, lv_svg_attr_t))->value.uval, 16);
197 lv_svg_node_delete(svg_node_ar);
198
199 const char * svg_ar9 = \
200 "<svg preserveAspectRatio=\"xMaxYMax meet\"></svg>";
201 svg_node_ar = lv_svg_load_data(svg_ar9, lv_strlen(svg_ar9));
202 TEST_ASSERT_EQUAL((LV_ARRAY_GET(&svg_node_ar->attrs, 0, lv_svg_attr_t))->value.uval, 18);
203 lv_svg_node_delete(svg_node_ar);
204
205 const char * svg_ar10 = \
206 "<svg preserveAspectRatio=\"unknown\"></svg>";
207 svg_node_ar = lv_svg_load_data(svg_ar10, lv_strlen(svg_ar10));
208 TEST_ASSERT_EQUAL(lv_array_size(&svg_node_ar->attrs), 1);
209 lv_svg_node_delete(svg_node_ar);
210 }
211
testPolylineElement(void)212 void testPolylineElement(void)
213 {
214 const char * svg_poly1 = \
215 "<svg><polyline points=\"100.0,50 200,150.0 180,110 200,200 210,340\"/></svg>";
216 lv_svg_node_t * svg_node_root = lv_svg_load_data(svg_poly1, lv_strlen(svg_poly1));
217 lv_svg_node_t * svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
218 TEST_ASSERT_EQUAL(((lv_svg_attr_values_list_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val)->length,
219 5);
220 lv_svg_node_delete(svg_node_root);
221
222 const char * svg_poly2 = \
223 "<svg><polyline points=\"\n100.0,50\t200,150.0\n180,110\r \"/></svg>";
224 svg_node_root = lv_svg_load_data(svg_poly2, lv_strlen(svg_poly2));
225 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
226 TEST_ASSERT_EQUAL(((lv_svg_attr_values_list_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val)->length,
227 3);
228 lv_svg_node_delete(svg_node_root);
229
230 const char * svg_poly3 = \
231 "<svg><polyline points=\"100.0 200,150.0 edf,err\"/></svg>";
232 svg_node_root = lv_svg_load_data(svg_poly3, lv_strlen(svg_poly3));
233 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
234 TEST_ASSERT_EQUAL(((lv_svg_attr_values_list_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val)->length,
235 1);
236 lv_svg_node_delete(svg_node_root);
237
238 const char * svg_poly4 = \
239 "<svg><polyline points=\"100.0\"/></svg>";
240 svg_node_root = lv_svg_load_data(svg_poly4, lv_strlen(svg_poly4));
241 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
242 TEST_ASSERT_EQUAL(((lv_svg_attr_values_list_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val)->length,
243 0);
244 lv_svg_node_delete(svg_node_root);
245
246 const char * svg_poly5 = \
247 "<svg><polyline points=\" \"/></svg>";
248 svg_node_root = lv_svg_load_data(svg_poly5, lv_strlen(svg_poly5));
249 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
250 TEST_ASSERT_EQUAL(lv_array_size(&svg_node->attrs), 0);
251 lv_svg_node_delete(svg_node_root);
252
253 }
254
testPathElement(void)255 void testPathElement(void)
256 {
257 const char * svg_path1 = \
258 "<svg><path d=\" \"/></svg>";
259 lv_svg_node_t * svg_node_root = lv_svg_load_data(svg_path1, lv_strlen(svg_path1));
260 lv_svg_node_t * svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
261 TEST_ASSERT_EQUAL(lv_array_size(&svg_node->attrs), 0);
262 lv_svg_node_delete(svg_node_root);
263
264 const char * svg_path2 = \
265 "<svg><path d=\"REt321\"/></svg>";
266 svg_node_root = lv_svg_load_data(svg_path2, lv_strlen(svg_path2));
267 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
268 TEST_ASSERT_EQUAL(((lv_svg_attr_values_list_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val)->length,
269 0);
270 lv_svg_node_delete(svg_node_root);
271
272 const char * svg_path3 = \
273 "<svg><path d=\"1223\"/></svg>";
274 svg_node_root = lv_svg_load_data(svg_path3, lv_strlen(svg_path3));
275 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
276 TEST_ASSERT_EQUAL(((lv_svg_attr_values_list_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val)->length,
277 0);
278 lv_svg_node_delete(svg_node_root);
279
280 const char * svg_path4 = \
281 "<svg><path d=\"m 100 200 150 180 L300 500 C 400 450 320.0 280.5 400 400 Z\"/></svg>";
282 svg_node_root = lv_svg_load_data(svg_path4, lv_strlen(svg_path4));
283 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
284 TEST_ASSERT_EQUAL(((lv_svg_attr_values_list_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val)->length,
285 5);
286 lv_svg_node_delete(svg_node_root);
287
288 const char * svg_path5 = \
289 "<svg><path d=\"M 100 200 300 500 L400 450 l 150 100 H 500 h 100 H 600 v 100 s 100 200 300 400\"/></svg>";
290 svg_node_root = lv_svg_load_data(svg_path5, lv_strlen(svg_path5));
291 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
292 TEST_ASSERT_EQUAL(((lv_svg_attr_values_list_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val)->length,
293 9);
294 uint32_t seg_size = sizeof(uint32_t) + sizeof(lv_svg_point_t);
295 lv_svg_attr_values_list_t * list = (lv_svg_attr_values_list_t *)(LV_ARRAY_GET(&svg_node->attrs, 0,
296 lv_svg_attr_t))->value.val;
297
298 lv_svg_attr_path_value_t * path = (lv_svg_attr_path_value_t *)(&list->data);
299 TEST_ASSERT_EQUAL(path->cmd, LV_SVG_PATH_CMD_MOVE_TO);
300
301 path = (lv_svg_attr_path_value_t *)((uint8_t *)&list->data + seg_size);
302 TEST_ASSERT_EQUAL(path->cmd, LV_SVG_PATH_CMD_LINE_TO);
303
304 path = (lv_svg_attr_path_value_t *)((uint8_t *)&list->data + seg_size * 2);
305 TEST_ASSERT_EQUAL(path->cmd, LV_SVG_PATH_CMD_LINE_TO);
306
307 TEST_ASSERT_EQUAL_FLOAT(((lv_svg_point_t *)(&path->data))->x, 400.0f);
308 TEST_ASSERT_EQUAL_FLOAT(((lv_svg_point_t *)(&path->data))->y, 450.0f);
309
310 path = (lv_svg_attr_path_value_t *)((uint8_t *)&list->data + seg_size * 7);
311 TEST_ASSERT_EQUAL(path->cmd, LV_SVG_PATH_CMD_LINE_TO);
312
313 TEST_ASSERT_EQUAL_FLOAT(((lv_svg_point_t *)(&path->data))->x, 600.0f);
314 TEST_ASSERT_EQUAL_FLOAT(((lv_svg_point_t *)(&path->data))->y, 650.0f);
315 lv_svg_node_delete(svg_node_root);
316
317 const char * svg_path6 = \
318 "<svg><path d=\"M 100 200 C300 500 400 450 320.0 280.5 c320 340 230 220 200 200"
319 " S400 400 450 450 s 500 450 550 550 q200 200 300 300 T400 400 l 450 450 480 520 t 500 500\"/></svg>";
320 svg_node_root = lv_svg_load_data(svg_path6, lv_strlen(svg_path6));
321 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
322 TEST_ASSERT_EQUAL(((lv_svg_attr_values_list_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val)->length,
323 10);
324 lv_svg_node_delete(svg_node_root);
325 }
326
testTransform(void)327 void testTransform(void)
328 {
329 const char * svg_tr1 = \
330 "<svg><g transform=\" \"/></svg>";
331 lv_svg_node_t * svg_node_root = lv_svg_load_data(svg_tr1, lv_strlen(svg_tr1));
332 lv_svg_node_t * svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
333 TEST_ASSERT_EQUAL(lv_array_size(&svg_node->attrs), 0);
334 lv_svg_node_delete(svg_node_root);
335
336 const char * svg_tr2 = \
337 "<svg><g transform=\"none\"/></svg>";
338 svg_node_root = lv_svg_load_data(svg_tr2, lv_strlen(svg_tr2));
339 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
340 TEST_ASSERT_EQUAL(lv_array_size(&svg_node->attrs), 1);
341 lv_svg_node_delete(svg_node_root);
342
343 const char * svg_tr3 = \
344 "<svg><g transform=\"matrix()\"/></svg>";
345 svg_node_root = lv_svg_load_data(svg_tr3, lv_strlen(svg_tr3));
346 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
347 lv_svg_matrix_t * matrix = (lv_svg_matrix_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val;
348
349 TEST_ASSERT_EQUAL_FLOAT(matrix->m[0][0], 1.0f);
350 TEST_ASSERT_EQUAL_FLOAT(matrix->m[1][1], 1.0f);
351 TEST_ASSERT_EQUAL_FLOAT(matrix->m[2][2], 1.0f);
352
353 lv_svg_node_delete(svg_node_root);
354
355 const char * svg_tr4 = \
356 "<svg><g transform=\"matrix(1.5, 0, 2.0, 2, 10, 20)\"/></svg>";
357 svg_node_root = lv_svg_load_data(svg_tr4, lv_strlen(svg_tr4));
358 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
359 matrix = (lv_svg_matrix_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val;
360
361 TEST_ASSERT_EQUAL_FLOAT(matrix->m[0][0], 1.5f);
362 TEST_ASSERT_EQUAL_FLOAT(matrix->m[1][0], 0.0f);
363 TEST_ASSERT_EQUAL_FLOAT(matrix->m[0][1], 2.0f);
364 TEST_ASSERT_EQUAL_FLOAT(matrix->m[1][1], 2.0f);
365 TEST_ASSERT_EQUAL_FLOAT(matrix->m[0][2], 10.0f);
366 TEST_ASSERT_EQUAL_FLOAT(matrix->m[1][2], 20.0f);
367
368 lv_svg_node_delete(svg_node_root);
369
370 const char * svg_tr5 = \
371 "<svg><g transform=\"translate(1, 2) translate(2.0, 2)\"/></svg>";
372 svg_node_root = lv_svg_load_data(svg_tr5, lv_strlen(svg_tr5));
373 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
374 matrix = (lv_svg_matrix_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val;
375
376 TEST_ASSERT_EQUAL_FLOAT(matrix->m[0][2], 3.0f);
377 TEST_ASSERT_EQUAL_FLOAT(matrix->m[1][2], 4.0f);
378
379 lv_svg_node_delete(svg_node_root);
380
381 const char * svg_tr6 = \
382 "<svg><g transform=\" scale(0.5) scale(0.5 0.5)\"/></svg>";
383 svg_node_root = lv_svg_load_data(svg_tr6, lv_strlen(svg_tr6));
384 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
385 matrix = (lv_svg_matrix_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val;
386
387 TEST_ASSERT_EQUAL_FLOAT(matrix->m[0][0], 0.25f);
388 TEST_ASSERT_EQUAL_FLOAT(matrix->m[1][1], 0.25f);
389
390 lv_svg_node_delete(svg_node_root);
391
392 const char * svg_tr7 = \
393 "<svg><g transform=\" translate(10 ) scale( 0.5 0.5) scale(0.5 ) \"/></svg>";
394 svg_node_root = lv_svg_load_data(svg_tr7, lv_strlen(svg_tr7));
395 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
396 matrix = (lv_svg_matrix_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val;
397
398 TEST_ASSERT_EQUAL_FLOAT(matrix->m[0][2], 10.0f);
399 TEST_ASSERT_EQUAL_FLOAT(matrix->m[1][2], 0.0f);
400 TEST_ASSERT_EQUAL_FLOAT(matrix->m[0][0], 0.25f);
401 TEST_ASSERT_EQUAL_FLOAT(matrix->m[1][1], 0.25f);
402
403 lv_svg_node_delete(svg_node_root);
404
405 const char * svg_tr8 = \
406 "<svg><g transform=\" rotate(90 10 10) \"/></svg>";
407 svg_node_root = lv_svg_load_data(svg_tr8, lv_strlen(svg_tr8));
408 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
409 matrix = (lv_svg_matrix_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val;
410
411 TEST_ASSERT_EQUAL_FLOAT(matrix->m[0][2], 20.0f);
412 TEST_ASSERT_EQUAL_FLOAT(matrix->m[1][2], 0.0f);
413
414 lv_svg_node_delete(svg_node_root);
415
416 const char * svg_tr9 = \
417 "<svg><g transform=\" rotate(90 ) \"/></svg>";
418 svg_node_root = lv_svg_load_data(svg_tr9, lv_strlen(svg_tr9));
419 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
420 matrix = (lv_svg_matrix_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val;
421
422 TEST_ASSERT_EQUAL_FLOAT(matrix->m[0][2], 0.0f);
423 TEST_ASSERT_EQUAL_FLOAT(matrix->m[1][2], 0.0f);
424
425 lv_svg_node_delete(svg_node_root);
426
427 const char * svg_tr10 = \
428 "<svg><g transform=\" skewX(10) skewY(10) \"/></svg>";
429 svg_node_root = lv_svg_load_data(svg_tr10, lv_strlen(svg_tr10));
430 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
431 matrix = (lv_svg_matrix_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val;
432
433 TEST_ASSERT_EQUAL_FLOAT(matrix->m[0][1], 0.176327f);
434 TEST_ASSERT_EQUAL_FLOAT(matrix->m[1][0], 0.176327f);
435
436 lv_svg_node_delete(svg_node_root);
437 }
438
testStrokeFill(void)439 void testStrokeFill(void)
440 {
441 const char * svg_sf1 = \
442 "<svg><g fill=\" \"/></svg>";
443 lv_svg_node_t * svg_node_root = lv_svg_load_data(svg_sf1, lv_strlen(svg_sf1));
444 lv_svg_node_t * svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
445 TEST_ASSERT_EQUAL(lv_array_size(&svg_node->attrs), 0);
446 lv_svg_node_delete(svg_node_root);
447
448 const char * svg_sf2 = \
449 "<svg><g fill=\"none\" stroke=\"inherit\"/></svg>";
450 svg_node_root = lv_svg_load_data(svg_sf2, lv_strlen(svg_sf2));
451 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
452 TEST_ASSERT_EQUAL(lv_array_size(&svg_node->attrs), 2);
453 lv_svg_node_delete(svg_node_root);
454
455 const char * svg_sf3 = \
456 "<svg><g fill=\" url(#grad1) \"/></svg>";
457 svg_node_root = lv_svg_load_data(svg_sf3, lv_strlen(svg_sf3));
458 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
459 const char * str = (const char *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.sval;
460 TEST_ASSERT_EQUAL_STRING(str, "grad1");
461 lv_svg_node_delete(svg_node_root);
462
463 const char * svg_sf4 = \
464 "<svg><g fill=\" url( # grad2 ) \"/></svg>";
465 svg_node_root = lv_svg_load_data(svg_sf4, lv_strlen(svg_sf4));
466 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
467 str = (const char *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.sval;
468 TEST_ASSERT_EQUAL_STRING(str, "");
469 lv_svg_node_delete(svg_node_root);
470
471 const char * svg_sf5 = \
472 "<svg><g fill=\" url( #grad2 ) \"/></svg>";
473 svg_node_root = lv_svg_load_data(svg_sf5, lv_strlen(svg_sf5));
474 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
475 str = (const char *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.sval;
476 TEST_ASSERT_EQUAL_STRING(str, "grad2");
477 lv_svg_node_delete(svg_node_root);
478
479 const char * svg_sf6 = \
480 "<svg><g fill=\" url (#grad2) \"/></svg>";
481 svg_node_root = lv_svg_load_data(svg_sf6, lv_strlen(svg_sf6));
482 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
483 uint32_t c = (LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.uval;
484 TEST_ASSERT_EQUAL(c, 0);
485 lv_svg_node_delete(svg_node_root);
486
487 const char * svg_sf7 = \
488 "<svg><g fill=\"rgb(255, 255, 255)\"/></svg>";
489 svg_node_root = lv_svg_load_data(svg_sf7, lv_strlen(svg_sf7));
490 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
491 c = (LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.uval;
492 TEST_ASSERT_EQUAL(c, 0xffffff);
493 lv_svg_node_delete(svg_node_root);
494
495 const char * svg_sf8 = \
496 "<svg><g fill=\"rgb(50%, 50%, 50%)\"/></svg>";
497 svg_node_root = lv_svg_load_data(svg_sf8, lv_strlen(svg_sf8));
498 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
499 c = (LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.uval;
500 TEST_ASSERT_EQUAL(c, 0x808080);
501 lv_svg_node_delete(svg_node_root);
502
503 const char * svg_sf9 = \
504 "<svg><g fill=\"#F00\"/></svg>";
505 svg_node_root = lv_svg_load_data(svg_sf9, lv_strlen(svg_sf9));
506 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
507 c = (LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.uval;
508 TEST_ASSERT_EQUAL(c, 0xff0000);
509 lv_svg_node_delete(svg_node_root);
510
511 const char * svg_sf10 = \
512 "<svg><g fill=\"#FF8000\"/></svg>";
513 svg_node_root = lv_svg_load_data(svg_sf10, lv_strlen(svg_sf10));
514 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
515 c = (LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.uval;
516 TEST_ASSERT_EQUAL(c, 0xff8000);
517 lv_svg_node_delete(svg_node_root);
518
519 const char * svg_sf11 = \
520 "<svg><g fill=\"red\"/></svg>";
521 svg_node_root = lv_svg_load_data(svg_sf11, lv_strlen(svg_sf11));
522 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
523 c = (LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.uval;
524 TEST_ASSERT_EQUAL(c, 0xff0000);
525 lv_svg_node_delete(svg_node_root);
526 }
527
testStrokeFillAttrs(void)528 void testStrokeFillAttrs(void)
529 {
530 const char * svg_sf0 = \
531 "<svg><g fill-rule=\'\'/></svg>";
532 lv_svg_node_t * svg_node_root = lv_svg_load_data(svg_sf0, lv_strlen(svg_sf0));
533 lv_svg_node_t * svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
534 TEST_ASSERT_EQUAL(lv_array_size(&svg_node->attrs), 0);
535 lv_svg_node_delete(svg_node_root);
536
537 const char * svg_sf1 = \
538 "<svg><g stroke-width=1 stroke-miterlimit=3 fill-rule=\'inherit\' /></svg>";
539 svg_node_root = lv_svg_load_data(svg_sf1, lv_strlen(svg_sf1));
540 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
541 float f1 = (LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.fval;
542 TEST_ASSERT_EQUAL_FLOAT(f1, 1.0f);
543 uint32_t f2 = (LV_ARRAY_GET(&svg_node->attrs, 1, lv_svg_attr_t))->value.ival;
544 TEST_ASSERT_EQUAL(f2, 3);
545 lv_svg_node_delete(svg_node_root);
546
547 const char * svg_sf2 = \
548 "<svg><g fill-rule=\"evenodd\" stroke-width=\'-1\' stroke-miterlimit=\'-5.0\'/></svg>";
549 svg_node_root = lv_svg_load_data(svg_sf2, lv_strlen(svg_sf2));
550 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
551 uint32_t r1 = (LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.ival;
552 TEST_ASSERT_EQUAL(r1, LV_SVG_FILL_EVENODD);
553 float w1 = (LV_ARRAY_GET(&svg_node->attrs, 1, lv_svg_attr_t))->value.fval;
554 TEST_ASSERT_EQUAL_FLOAT(w1, 0.0f);
555 uint32_t l1 = (LV_ARRAY_GET(&svg_node->attrs, 2, lv_svg_attr_t))->value.uval;
556 TEST_ASSERT_EQUAL(l1, 1);
557 lv_svg_node_delete(svg_node_root);
558
559 const char * svg_sf3 = \
560 "<svg><g stroke-linecap=\"round\" stroke-linejoin=\' bevel\' fill-rule=nonzero/></svg>";
561 svg_node_root = lv_svg_load_data(svg_sf3, lv_strlen(svg_sf3));
562 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
563 uint32_t c1 = (LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.ival;
564 TEST_ASSERT_EQUAL(c1, LV_SVG_LINE_CAP_ROUND);
565 uint32_t c2 = (LV_ARRAY_GET(&svg_node->attrs, 1, lv_svg_attr_t))->value.ival;
566 TEST_ASSERT_EQUAL(c2, LV_SVG_LINE_JOIN_BEVEL);
567 uint32_t r2 = (LV_ARRAY_GET(&svg_node->attrs, 2, lv_svg_attr_t))->value.ival;
568 TEST_ASSERT_EQUAL(r2, LV_SVG_FILL_NONZERO);
569 lv_svg_node_delete(svg_node_root);
570
571 const char * svg_sf4 = \
572 "<svg><g stroke-linecap=\" square \" stroke-linejoin=round/></svg>";
573 svg_node_root = lv_svg_load_data(svg_sf4, lv_strlen(svg_sf4));
574 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
575 uint32_t c3 = (LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.ival;
576 TEST_ASSERT_EQUAL(c3, LV_SVG_LINE_CAP_SQUARE);
577 uint32_t c4 = (LV_ARRAY_GET(&svg_node->attrs, 1, lv_svg_attr_t))->value.ival;
578 TEST_ASSERT_EQUAL(c4, LV_SVG_LINE_JOIN_ROUND);
579 lv_svg_node_delete(svg_node_root);
580
581 const char * svg_sf5 = \
582 "<svg><g stroke-linecap=\"a\" stroke-linejoin=\'b\' stroke-dasharray=\"none\" stroke-opacity=\"inherit\"/></svg>";
583 svg_node_root = lv_svg_load_data(svg_sf5, lv_strlen(svg_sf5));
584 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
585 uint32_t c5 = (LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.ival;
586 TEST_ASSERT_EQUAL(c5, LV_SVG_LINE_CAP_BUTT);
587 uint32_t c6 = (LV_ARRAY_GET(&svg_node->attrs, 1, lv_svg_attr_t))->value.ival;
588 TEST_ASSERT_EQUAL(c6, LV_SVG_LINE_JOIN_MITER);
589 lv_svg_node_delete(svg_node_root);
590
591 const char * svg_sf6 = \
592 "<svg><g stroke-dasharray=\"1,2,3, 2.5, 3 \" stroke-dashoffset=1.2"
593 " fill-opacity=\"2.0\" stroke-dasharray=\"inherit\" /></svg>";
594 svg_node_root = lv_svg_load_data(svg_sf6, lv_strlen(svg_sf6));
595 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
596 lv_svg_attr_values_list_t * list = (lv_svg_attr_values_list_t *)(LV_ARRAY_GET(&svg_node->attrs, 0,
597 lv_svg_attr_t))->value.val;
598 TEST_ASSERT_EQUAL(list->length, 5);
599 float * arr = (float *)(&list->data);
600 float ret[5] = {1.0f, 2.0f, 3.0f, 2.5f, 3.0f};
601 TEST_ASSERT_EQUAL_FLOAT_ARRAY(ret, arr, 5);
602
603 float c8 = (LV_ARRAY_GET(&svg_node->attrs, 1, lv_svg_attr_t))->value.fval;
604 TEST_ASSERT_EQUAL_FLOAT(c8, 1.2f);
605 float c9 = (LV_ARRAY_GET(&svg_node->attrs, 2, lv_svg_attr_t))->value.fval;
606 TEST_ASSERT_EQUAL_FLOAT(c9, 1.0f);
607 lv_svg_node_delete(svg_node_root);
608 }
609
testTextAttrs(void)610 void testTextAttrs(void)
611 {
612 const char * svg_sf0 = \
613 "<svg><text font-size=\'16\' font-family=\"arial\" font-variant=inherit>hello world!</text></svg>";
614 lv_svg_node_t * svg_node_root = lv_svg_load_data(svg_sf0, lv_strlen(svg_sf0));
615 lv_svg_node_t * svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
616
617 float font_size = (LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.fval;
618 TEST_ASSERT_EQUAL_FLOAT(font_size, 16.0f);
619 const char * font_family = (LV_ARRAY_GET(&svg_node->attrs, 1, lv_svg_attr_t))->value.sval;
620 TEST_ASSERT_EQUAL_STRING(font_family, "arial");
621 lv_svg_node_t * svg_node1 = LV_SVG_NODE_CHILD(svg_node, 0);
622 const char * content = svg_node1->xml_id;
623 TEST_ASSERT_EQUAL_STRING(content, "hello world!");
624 lv_svg_node_delete(svg_node_root);
625
626 const char * svg_sf1 = \
627 "<svg><text font-size=\'16em\' font=\'user\' font-style=\" italic \" >hello<tspan>my\n</tspan>world!</text></svg>";
628 svg_node_root = lv_svg_load_data(svg_sf1, lv_strlen(svg_sf1));
629 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
630
631 font_size = (LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.fval;
632 TEST_ASSERT_EQUAL_FLOAT(font_size, 256.0f);
633 const char * font_style = (LV_ARRAY_GET(&svg_node->attrs, 1, lv_svg_attr_t))->value.sval;
634 TEST_ASSERT_EQUAL_STRING(font_style, "italic ");
635 svg_node1 = LV_SVG_NODE_CHILD(svg_node, 0);
636 const char * content1 = svg_node1->xml_id;
637 TEST_ASSERT_EQUAL_STRING(content1, "hello");
638 svg_node1 = LV_SVG_NODE_CHILD(svg_node, 2);
639 const char * content2 = svg_node1->xml_id;
640 TEST_ASSERT_EQUAL_STRING(content2, "world!");
641 svg_node1 = LV_SVG_NODE_CHILD(svg_node, 1);
642 lv_svg_node_t * svg_node2 = LV_SVG_NODE_CHILD(svg_node1, 0);
643 const char * content3 = svg_node2->xml_id;
644 TEST_ASSERT_EQUAL_STRING(content3, "my");
645 lv_svg_node_delete(svg_node_root);
646 }
647
testGradient(void)648 void testGradient(void)
649 {
650 const char * svg_gt1 = \
651 "<svg><linearGradient id=\"gt1\" gradientUnits= objectBoundingBox>"
652 "<stop stop-color='red' offset=0.1/>"
653 "<stop stop-color=\'black\' stop-opacity=\"0.5\" offset=1.0/>"
654 "</linearGradient></svg>";
655 lv_svg_node_t * svg_node_root = lv_svg_load_data(svg_gt1, lv_strlen(svg_gt1));
656 lv_svg_node_t * svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
657 TEST_ASSERT_EQUAL_STRING(svg_node->xml_id, "gt1");
658 lv_svg_node_t * svg_node1 = LV_SVG_NODE_CHILD(svg_node, 1);
659 uint32_t c1 = (LV_ARRAY_GET(&svg_node1->attrs, 0, lv_svg_attr_t))->value.uval;
660 TEST_ASSERT_EQUAL(c1, 0);
661 float o1 = (LV_ARRAY_GET(&svg_node1->attrs, 1, lv_svg_attr_t))->value.fval;
662 TEST_ASSERT_EQUAL_FLOAT(o1, 0.5f);
663 float o2 = (LV_ARRAY_GET(&svg_node1->attrs, 2, lv_svg_attr_t))->value.fval;
664 TEST_ASSERT_EQUAL_FLOAT(o2, 1.0f);
665 lv_svg_node_delete(svg_node_root);
666
667 const char * svg_gt2 = \
668 "<svg><defs><radialGradient xml:id=\"gt2\" gradientUnits=\"userSpaceOnUse\""
669 "cx=\"400\" cy=\"200\" r=\"300\">"
670 "<stop offset=\"0\" stop-color=\"red\"/>"
671 "<stop offset=\"0.5\" stop-color=\"blue\"/>"
672 "<stop offset=\"1\" stop-color=\"red\"/>"
673 "</radialGradient></defs></svg>";
674 svg_node_root = lv_svg_load_data(svg_gt2, lv_strlen(svg_gt2));
675 svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0); //defs
676 svg_node1 = LV_SVG_NODE_CHILD(svg_node, 0);
677 TEST_ASSERT_EQUAL_STRING(svg_node1->xml_id, "gt2");
678 uint32_t g = (LV_ARRAY_GET(&svg_node1->attrs, 0, lv_svg_attr_t))->value.ival;
679 TEST_ASSERT_EQUAL(g, LV_SVG_GRADIENT_UNITS_USER_SPACE);
680 float cx = (LV_ARRAY_GET(&svg_node1->attrs, 1, lv_svg_attr_t))->value.fval;
681 TEST_ASSERT_EQUAL_FLOAT(cx, 400.0f);
682 float cy = (LV_ARRAY_GET(&svg_node1->attrs, 2, lv_svg_attr_t))->value.fval;
683 TEST_ASSERT_EQUAL_FLOAT(cy, 200.0f);
684 lv_svg_node_delete(svg_node_root);
685 }
686
testBadCase(void)687 void testBadCase(void)
688 {
689 const char * svg_b1 = \
690 "<rect x=10 y=10 width=100 height=100/>";
691 lv_svg_node_t * svg = lv_svg_load_data(svg_b1, lv_strlen(svg_b1));
692 TEST_ASSERT_EQUAL(NULL, svg);
693 lv_svg_node_delete(svg);
694
695 const char * svg_b2 = \
696 "<svg><text><rect x=10 y=10 width=200 height=200/></svg>";
697 svg = lv_svg_load_data(svg_b2, lv_strlen(svg_b2));
698 TEST_ASSERT_EQUAL(NULL, svg);
699 lv_svg_node_delete(svg);
700
701 const char * svg_b3 = \
702 "<svg><rect x=10 y=10 width=200 height/></svg>";
703 svg = lv_svg_load_data(svg_b3, lv_strlen(svg_b3));
704 TEST_ASSERT_EQUAL(NULL, svg);
705 lv_svg_node_delete(svg);
706
707 const char * svg_b4 = \
708 "<svg><g fill=\"url( \"/></svg>";
709 svg = lv_svg_load_data(svg_b4, lv_strlen(svg_b4));
710 lv_svg_node_t * svg_node = LV_SVG_NODE_CHILD(svg, 0);
711 TEST_ASSERT_EQUAL(0, LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t)->class_type);
712 lv_svg_node_delete(svg);
713
714 const char * svg_b5 = \
715 "<svg><g transform=matrix/></svg>";
716 svg = lv_svg_load_data(svg_b5, lv_strlen(svg_b5));
717 svg_node = LV_SVG_NODE_CHILD(svg, 0);
718 lv_svg_matrix_t * matrix = (lv_svg_matrix_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val;
719
720 TEST_ASSERT_EQUAL_FLOAT(matrix->m[0][0], 1.0f);
721 TEST_ASSERT_EQUAL_FLOAT(matrix->m[1][1], 1.0f);
722 TEST_ASSERT_EQUAL_FLOAT(matrix->m[2][2], 1.0f);
723 lv_svg_node_delete(svg);
724
725 const char * svg_b6 = \
726 "<svg><123><123></svg>";
727 svg = lv_svg_load_data(svg_b6, lv_strlen(svg_b6));
728 TEST_ASSERT_EQUAL(NULL, svg);
729 lv_svg_node_delete(svg);
730
731 const char * svg_b7 = \
732 "<svg><my> bad case <you></svg>";
733 svg = lv_svg_load_data(svg_b7, lv_strlen(svg_b7));
734 TEST_ASSERT_EQUAL(NULL, svg);
735 lv_svg_node_delete(svg);
736
737 const char * svg_b8 = \
738 "<svg><path d=\"M 100 L150 180 L 150 Z\"/></svg>";
739 svg = lv_svg_load_data(svg_b8, lv_strlen(svg_b8));
740 svg_node = LV_SVG_NODE_CHILD(svg, 0);
741 TEST_ASSERT_EQUAL(((lv_svg_attr_values_list_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val)->length,
742 3);
743 uint32_t seg_size = sizeof(uint32_t) + sizeof(lv_svg_point_t);
744 lv_svg_attr_values_list_t * list = (lv_svg_attr_values_list_t *)(LV_ARRAY_GET(&svg_node->attrs, 0,
745 lv_svg_attr_t))->value.val;
746
747 lv_svg_attr_path_value_t * path = (lv_svg_attr_path_value_t *)(&list->data);
748 TEST_ASSERT_EQUAL(path->cmd, LV_SVG_PATH_CMD_MOVE_TO);
749
750 TEST_ASSERT_EQUAL_FLOAT(((lv_svg_point_t *)(&path->data))->x, 100.0f);
751 TEST_ASSERT_EQUAL_FLOAT(((lv_svg_point_t *)(&path->data))->y, 150.0f);
752
753 path = (lv_svg_attr_path_value_t *)((uint8_t *)&list->data + seg_size);
754 TEST_ASSERT_EQUAL(path->cmd, LV_SVG_PATH_CMD_LINE_TO);
755
756 TEST_ASSERT_EQUAL_FLOAT(((lv_svg_point_t *)(&path->data))->x, 180.0f);
757 TEST_ASSERT_EQUAL_FLOAT(((lv_svg_point_t *)(&path->data))->y, 150.0f);
758 lv_svg_node_delete(svg);
759
760 const char * svg_b9 = \
761 "<svg><path d=\"M 100 200 L150 Z\"/></svg>";
762 svg = lv_svg_load_data(svg_b9, lv_strlen(svg_b9));
763 svg_node = LV_SVG_NODE_CHILD(svg, 0);
764 TEST_ASSERT_EQUAL(((lv_svg_attr_values_list_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val)->length,
765 1);
766 seg_size = sizeof(uint32_t) + sizeof(lv_svg_point_t);
767 list = (lv_svg_attr_values_list_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val;
768
769 path = (lv_svg_attr_path_value_t *)(&list->data);
770 TEST_ASSERT_EQUAL(path->cmd, LV_SVG_PATH_CMD_MOVE_TO);
771
772 TEST_ASSERT_EQUAL_FLOAT(((lv_svg_point_t *)(&path->data))->x, 100.0f);
773 TEST_ASSERT_EQUAL_FLOAT(((lv_svg_point_t *)(&path->data))->y, 200.0f);
774 lv_svg_node_delete(svg);
775
776 const char * svg_b10 = \
777 "<svg></text>bad case</text></svg>";
778 svg = lv_svg_load_data(svg_b10, lv_strlen(svg_b10));
779 TEST_ASSERT_EQUAL(NULL, svg);
780 lv_svg_node_delete(svg);
781
782 const char * svg_b11 = \
783 "<svg><text font-size></text></svg>";
784 svg = lv_svg_load_data(svg_b11, lv_strlen(svg_b11));
785 svg_node = LV_SVG_NODE_CHILD(svg, 0);
786 TEST_ASSERT_EQUAL(lv_array_size(&svg_node->attrs), 0);
787 TEST_ASSERT_EQUAL(LV_TREE_NODE(svg_node)->child_cnt, 0);
788 lv_svg_node_delete(svg);
789
790 const char * svg_b12 = \
791 "<svg><text font-size=></text></svg>";
792 svg = lv_svg_load_data(svg_b12, lv_strlen(svg_b12));
793 svg_node = LV_SVG_NODE_CHILD(svg, 0);
794 TEST_ASSERT_EQUAL(lv_array_size(&svg_node->attrs), 0);
795 TEST_ASSERT_EQUAL(LV_TREE_NODE(svg_node)->child_cnt, 0);
796 lv_svg_node_delete(svg);
797
798 const char * svg_b13 = \
799 "<svg><!-aaaa /></svg>";
800 svg = lv_svg_load_data(svg_b13, lv_strlen(svg_b13));
801 TEST_ASSERT_NOT_EQUAL(NULL, svg);
802 lv_svg_node_delete(svg);
803
804 const char * svg_b14 = \
805 "<svg><rect"
806 "x=1 y=1 width=10 height=10"
807 "x=1 y=1 width=10 height=10"
808 "x=1 y=1 width=10 height=10"
809 " /></svg>";
810 svg = lv_svg_load_data(svg_b14, lv_strlen(svg_b14));
811 TEST_ASSERT_NOT_EQUAL(NULL, svg);
812 lv_svg_node_delete(svg);
813
814 const char * svg_b15 = \
815 "<svg>"
816 "<path d=\'m-122.3,84.285s0.1,1.894-0.73,1.875c-0.82-0.019-17.27-48.094-37.8-45.851,0,0,17.78-7.353,38.53,43.976z\'/>"
817 "</svg>";
818 svg = lv_svg_load_data(svg_b15, lv_strlen(svg_b15));
819 svg_node = LV_SVG_NODE_CHILD(svg, 0);
820
821 TEST_ASSERT_EQUAL(((lv_svg_attr_values_list_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val)->length,
822 5);
823 seg_size = sizeof(uint32_t) + sizeof(lv_svg_point_t);
824 list = (lv_svg_attr_values_list_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val;
825
826 path = (lv_svg_attr_path_value_t *)(&list->data);
827 TEST_ASSERT_EQUAL(path->cmd, LV_SVG_PATH_CMD_MOVE_TO);
828
829 TEST_ASSERT_EQUAL_FLOAT(((lv_svg_point_t *)(&path->data))->x, -122.3f);
830 TEST_ASSERT_EQUAL_FLOAT(((lv_svg_point_t *)(&path->data))->y, 84.285f);
831
832 lv_svg_node_delete(svg);
833
834 const char * svg_b16 = \
835 "<svg>"
836 "<g transform=\'matrix(1.7656463,0,0,1.7656463,324.90716,255.00942)\'>"
837 "</g>"
838 "</svg>";
839 svg = lv_svg_load_data(svg_b16, lv_strlen(svg_b16));
840 svg_node = LV_SVG_NODE_CHILD(svg, 0);
841 matrix = (lv_svg_matrix_t *)(LV_ARRAY_GET(&svg_node->attrs, 0, lv_svg_attr_t))->value.val;
842
843 TEST_ASSERT_EQUAL_FLOAT(matrix->m[0][0], 1.7656463f);
844 TEST_ASSERT_EQUAL_FLOAT(matrix->m[1][0], 0.0f);
845 TEST_ASSERT_EQUAL_FLOAT(matrix->m[0][1], 0.0f);
846 TEST_ASSERT_EQUAL_FLOAT(matrix->m[1][1], 1.7656463f);
847 TEST_ASSERT_EQUAL_FLOAT(matrix->m[0][2], 324.90716f);
848 TEST_ASSERT_EQUAL_FLOAT(matrix->m[1][2], 255.00942f);
849
850 lv_svg_node_delete(svg);
851 }
852
853 #endif
854
