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 
setUp(void)8 void setUp(void)
9 {
10 }
11 
tearDown(void)12 void tearDown(void)
13 {
14 }
15 
testAnimate(void)16 void testAnimate(void)
17 {
18     const char * svg_anim0 = \
19                              "<svg><rect xml:id=\"RectElement\" x=\"300\" y=\"100\" width=\"300\" height=\"100\">"
20                              "<animate attributeName=\"x\" dur=\"9s\" fill=\"freeze\" from=\"300\" to=\"0\"/>"
21                              "</rect></svg>";
22 
23     lv_svg_node_t * svg_node_root = lv_svg_load_data(svg_anim0, lv_strlen(svg_anim0));
24     lv_svg_node_t * svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
25     lv_svg_node_t * anim_node = LV_SVG_NODE_CHILD(svg_node, 0);
26     TEST_ASSERT_NOT_EQUAL(NULL, anim_node);
27     TEST_ASSERT_EQUAL(LV_SVG_TAG_ANIMATE, anim_node->type);
28     lv_svg_attr_type_t at = (LV_ARRAY_GET(&anim_node->attrs, 0, lv_svg_attr_t))->value.ival;
29     TEST_ASSERT_EQUAL(LV_SVG_ATTR_X, at);
30     float dur = (LV_ARRAY_GET(&anim_node->attrs, 1, lv_svg_attr_t))->value.fval;
31     TEST_ASSERT_EQUAL_FLOAT(dur, 9000.0f);
32 
33     int ft = (LV_ARRAY_GET(&anim_node->attrs, 2, lv_svg_attr_t))->value.ival;
34     TEST_ASSERT_EQUAL(ft, LV_SVG_ANIM_FREEZE);
35 
36     float fr = (LV_ARRAY_GET(&anim_node->attrs, 3, lv_svg_attr_t))->value.fval;
37     TEST_ASSERT_EQUAL_FLOAT(fr, 300.0f);
38 
39     float to = (LV_ARRAY_GET(&anim_node->attrs, 4, lv_svg_attr_t))->value.fval;
40     TEST_ASSERT_EQUAL_FLOAT(to, 0.0f);
41 
42     lv_svg_node_delete(svg_node_root);
43 }
44 
testSet(void)45 void testSet(void)
46 {
47     const char * svg_anim0 = \
48                              "<svg><rect xml:id=\"RectElement\" x=\"300\" y=\"100\" width=\"300\" height=\"100\">"
49                              "<set attributeName=\"x\" to=\"500\" values=\"0\"/>"
50                              "</rect></svg>";
51 
52     lv_svg_node_t * svg_node_root = lv_svg_load_data(svg_anim0, lv_strlen(svg_anim0));
53     lv_svg_node_t * svg_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
54     lv_svg_node_t * anim_node = LV_SVG_NODE_CHILD(svg_node, 0);
55     TEST_ASSERT_NOT_EQUAL(NULL, anim_node);
56     TEST_ASSERT_EQUAL(LV_SVG_TAG_SET, anim_node->type);
57     lv_svg_attr_type_t at = (LV_ARRAY_GET(&anim_node->attrs, 0, lv_svg_attr_t))->value.ival;
58     TEST_ASSERT_EQUAL(LV_SVG_ATTR_X, at);
59     float to = (LV_ARRAY_GET(&anim_node->attrs, 1, lv_svg_attr_t))->value.fval;
60     TEST_ASSERT_EQUAL_FLOAT(to, 500.0f);
61 
62     lv_svg_node_delete(svg_node_root);
63 }
64 
testAnimateMotion(void)65 void testAnimateMotion(void)
66 {
67     const char * svg_anim0 = \
68                              "<svg><path xml:id=\"path1\" d=\"M100,250 C 100,50 400,50 400,250\" "
69                              "fill=\"none\" stroke=\"blue\" stroke-width=\"7.06\"/>"
70                              "<animateMotion dur=\"6s\" repeatCount=\"indefinite\" rotate=\"auto\">"
71                              "<mpath xlink:href=\"#path1\"/>"
72                              "</animateMotion>"
73                              "</svg>";
74 
75     lv_svg_node_t * svg_node_root = lv_svg_load_data(svg_anim0, lv_strlen(svg_anim0));
76     lv_svg_node_t * path_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
77     TEST_ASSERT_NOT_EQUAL(NULL, path_node);
78     lv_svg_node_t * anim_node = LV_SVG_NODE_CHILD(svg_node_root, 1);
79     TEST_ASSERT_NOT_EQUAL(NULL, anim_node);
80     TEST_ASSERT_EQUAL(LV_SVG_TAG_ANIMATE_MOTION, anim_node->type);
81 
82     lv_svg_node_t * mpath_node = LV_SVG_NODE_CHILD(anim_node, 0);
83     TEST_ASSERT_NOT_EQUAL(NULL, mpath_node);
84     TEST_ASSERT_EQUAL(LV_SVG_TAG_MPATH, mpath_node->type);
85 
86     const char * xlink = (LV_ARRAY_GET(&mpath_node->attrs, 0, lv_svg_attr_t))->value.sval;
87     TEST_ASSERT_EQUAL_STRING(xlink, path_node->xml_id);
88 
89     uint32_t rp = (LV_ARRAY_GET(&anim_node->attrs, 1, lv_svg_attr_t))->value.uval;
90     TEST_ASSERT_EQUAL(rp, 0);
91 
92     float rt = (LV_ARRAY_GET(&anim_node->attrs, 2, lv_svg_attr_t))->value.fval;
93     TEST_ASSERT_EQUAL_FLOAT(rt, 0.0f);
94     lv_svg_node_delete(svg_node_root);
95 
96     const char * svg_anim1 = \
97                              "<svg><circle r=\"5\" fill=\"blue\">"
98                              "<animateMotion begin=\"500ms\" dur=\"3.1s\" calcMode=\"linear\" keyPoints=\"0.5; 0.8; 1.0\" path=\"M15,43 C15,43 36,20 65,33\"/>"
99                              "</circle>"
100                              "</svg>";
101 
102     svg_node_root = lv_svg_load_data(svg_anim1, lv_strlen(svg_anim1));
103     path_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
104     anim_node = LV_SVG_NODE_CHILD(path_node, 0);
105     TEST_ASSERT_NOT_EQUAL(NULL, anim_node);
106     TEST_ASSERT_EQUAL(LV_SVG_TAG_ANIMATE_MOTION, anim_node->type);
107 
108     lv_svg_attr_values_list_t * lb = (LV_ARRAY_GET(&anim_node->attrs, 0, lv_svg_attr_t))->value.val;
109     TEST_ASSERT_EQUAL(lb->length, 1);
110     float * fb = (float *)(&lb->data);
111     TEST_ASSERT_EQUAL_FLOAT(*fb, 500.0f);
112 
113     float dr = (LV_ARRAY_GET(&anim_node->attrs, 1, lv_svg_attr_t))->value.fval;
114     TEST_ASSERT_EQUAL(dr, 3100.0f);
115 
116     int cm = (LV_ARRAY_GET(&anim_node->attrs, 2, lv_svg_attr_t))->value.ival;
117     TEST_ASSERT_EQUAL(cm, LV_SVG_ANIM_CALC_MODE_LINEAR);
118 
119     lv_svg_attr_values_list_t * l = (LV_ARRAY_GET(&anim_node->attrs, 3, lv_svg_attr_t))->value.val;
120     TEST_ASSERT_EQUAL(l->length, 3);
121 
122     float * pt = (float *)(&l->data);
123     TEST_ASSERT_EQUAL_FLOAT(pt[0], 0.5f);
124     TEST_ASSERT_EQUAL_FLOAT(pt[1], 0.8f);
125     TEST_ASSERT_EQUAL_FLOAT(pt[2], 1.0f);
126 
127     lv_svg_attr_values_list_t * lp = (LV_ARRAY_GET(&anim_node->attrs, 4, lv_svg_attr_t))->value.val;
128     TEST_ASSERT_EQUAL(lp->length, 2);
129     lv_svg_node_delete(svg_node_root);
130 
131     const char * svg_anim2 = \
132                              "<svg><circle r=\"5\" fill=\"blue\">"
133                              "<animateMotion begin=\"5s;2s\" end=\"8s;10s\" values=\"100, 50;200 200\" keyTimes=\"100ms;200ms\""
134                              " keySplines=\"0 0 1.5 1.0; 0.5 0.5, 2.0,1.5\" additive=\"sum\" accumulate=\"none\"/>"
135                              "</circle>"
136                              "</svg>";
137 
138     svg_node_root = lv_svg_load_data(svg_anim2, lv_strlen(svg_anim2));
139     path_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
140     anim_node = LV_SVG_NODE_CHILD(path_node, 0);
141     TEST_ASSERT_NOT_EQUAL(NULL, anim_node);
142     TEST_ASSERT_EQUAL(LV_SVG_TAG_ANIMATE_MOTION, anim_node->type);
143 
144     lb = (LV_ARRAY_GET(&anim_node->attrs, 0, lv_svg_attr_t))->value.val;
145     TEST_ASSERT_EQUAL(lb->length, 2);
146     fb = (float *)(&lb->data);
147     TEST_ASSERT_EQUAL_FLOAT(fb[0], 5000.0f);
148     TEST_ASSERT_EQUAL_FLOAT(fb[1], 2000.0f);
149 
150     lb = (LV_ARRAY_GET(&anim_node->attrs, 1, lv_svg_attr_t))->value.val;
151     TEST_ASSERT_EQUAL(lb->length, 2);
152     fb = (float *)(&lb->data);
153     TEST_ASSERT_EQUAL_FLOAT(fb[0], 8000.0f);
154     TEST_ASSERT_EQUAL_FLOAT(fb[1], 10000.0f);
155 
156     lb = (LV_ARRAY_GET(&anim_node->attrs, 2, lv_svg_attr_t))->value.val;
157     TEST_ASSERT_EQUAL(lb->length, 2);
158     lv_svg_point_t * ps = (lv_svg_point_t *)(&lb->data);
159     TEST_ASSERT_EQUAL_FLOAT(ps[0].x, 100.0f);
160     TEST_ASSERT_EQUAL_FLOAT(ps[0].y, 50.0f);
161     TEST_ASSERT_EQUAL_FLOAT(ps[1].x, 200.0f);
162     TEST_ASSERT_EQUAL_FLOAT(ps[1].y, 200.0f);
163 
164     lb = (LV_ARRAY_GET(&anim_node->attrs, 3, lv_svg_attr_t))->value.val;
165     TEST_ASSERT_EQUAL(lb->length, 2);
166     fb = (float *)(&lb->data);
167     TEST_ASSERT_EQUAL_FLOAT(fb[0], 100.0f);
168     TEST_ASSERT_EQUAL_FLOAT(fb[1], 200.0f);
169 
170     l = (LV_ARRAY_GET(&anim_node->attrs, 4, lv_svg_attr_t))->value.val;
171     TEST_ASSERT_EQUAL(l->length, 4);
172 
173     ps = (lv_svg_point_t *)(&l->data);
174     TEST_ASSERT_EQUAL_FLOAT(ps[0].x, 0.0f);
175     TEST_ASSERT_EQUAL_FLOAT(ps[0].y, 0.0f);
176     TEST_ASSERT_EQUAL_FLOAT(ps[1].x, 1.5f);
177     TEST_ASSERT_EQUAL_FLOAT(ps[1].y, 1.0f);
178     TEST_ASSERT_EQUAL_FLOAT(ps[2].x, 0.5f);
179     TEST_ASSERT_EQUAL_FLOAT(ps[2].y, 0.5f);
180     TEST_ASSERT_EQUAL_FLOAT(ps[3].x, 2.0f);
181     TEST_ASSERT_EQUAL_FLOAT(ps[3].y, 1.5f);
182 
183     lv_svg_node_delete(svg_node_root);
184 }
185 
testAnimateTransform(void)186 void testAnimateTransform(void)
187 {
188     const char * svg_anim0 = \
189                              "<svg><rect transform=\"skewX(30)\" x=0 y=0 width=100 height=100>"
190                              "<animateTransform attributeName=\"transform\" attributeType=\"XML\""
191                              "type=\"rotate\" from=\"0\" to=\"90\" dur=\"5s\""
192                              "additive=\"sum\" fill=\"freeze\"/>"
193                              "<animateTransform attributeName=\"transform\" attributeType=\"XML\""
194                              "type=\"scale\" from=\"1\" to=\"2\" dur=\"5s\" values=\"0.5; 0.2, 0.2\""
195                              "additive=\"sum\" fill=\"freeze\"/>"
196                              "</rect></svg>";
197 
198     lv_svg_node_t * svg_node_root = lv_svg_load_data(svg_anim0, lv_strlen(svg_anim0));
199     lv_svg_node_t * path_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
200     TEST_ASSERT_NOT_EQUAL(NULL, path_node);
201     lv_svg_node_t * anim_node1 = LV_SVG_NODE_CHILD(path_node, 0);
202     TEST_ASSERT_NOT_EQUAL(NULL, anim_node1);
203     TEST_ASSERT_EQUAL(LV_SVG_TAG_ANIMATE_TRANSFORM, anim_node1->type);
204     lv_svg_node_t * anim_node2 = LV_SVG_NODE_CHILD(path_node, 1);
205     TEST_ASSERT_NOT_EQUAL(NULL, anim_node2);
206     TEST_ASSERT_EQUAL(LV_SVG_TAG_ANIMATE_TRANSFORM, anim_node2->type);
207 
208     lv_svg_attr_type_t at = (LV_ARRAY_GET(&anim_node1->attrs, 0, lv_svg_attr_t))->value.ival;
209     TEST_ASSERT_EQUAL(LV_SVG_ATTR_TRANSFORM, at);
210 
211     lv_svg_transform_type_t tt = (LV_ARRAY_GET(&anim_node1->attrs, 1, lv_svg_attr_t))->value.ival;
212     TEST_ASSERT_EQUAL(LV_SVG_TRANSFORM_TYPE_ROTATE, tt);
213 
214     lv_svg_attr_values_list_t * l = (LV_ARRAY_GET(&anim_node1->attrs, 2, lv_svg_attr_t))->value.val;
215     TEST_ASSERT_EQUAL(l->length, 1);
216     float * pt = (float *)(&l->data);
217     TEST_ASSERT_EQUAL_FLOAT(pt[0], 0.0f);
218 
219     l = (LV_ARRAY_GET(&anim_node2->attrs, 5, lv_svg_attr_t))->value.val;
220     TEST_ASSERT_EQUAL(l->length, 2);
221     lv_svg_attr_values_list_t * ll = (lv_svg_attr_values_list_t *)(&l->data);
222     TEST_ASSERT_EQUAL(ll->length, 1);
223     pt = (float *)(&ll->data);
224     TEST_ASSERT_EQUAL_FLOAT(pt[0], 0.5f);
225 
226     ll = (lv_svg_attr_values_list_t *)((uint8_t *)(&l->data) + sizeof(uint32_t) + sizeof(float) * 4);
227     TEST_ASSERT_EQUAL(ll->length, 2);
228     pt = (float *)(&ll->data);
229     TEST_ASSERT_EQUAL_FLOAT(pt[0], 0.2f);
230     TEST_ASSERT_EQUAL_FLOAT(pt[1], 0.2f);
231 
232     lv_svg_node_delete(svg_node_root);
233 }
234 
testAnimateColor(void)235 void testAnimateColor(void)
236 {
237     const char * svg_anim0 = \
238                              "<svg><rect color=\"yellow\" fill=\"black\">"
239                              "<animateColor attributeName=\"fill\" from=\"red\" to=\"#DDF\" "
240                              "begin=\"1s\" dur=\"5s\" fill=\"freeze\" additive=\"sum\" repeatCount=5 restart=\"whenNotActive\" values=\"rgb(0,255,0);black\" />"
241                              "</rect></svg>";
242 
243     lv_svg_node_t * svg_node_root = lv_svg_load_data(svg_anim0, lv_strlen(svg_anim0));
244     lv_svg_node_t * path_node = LV_SVG_NODE_CHILD(svg_node_root, 0);
245     TEST_ASSERT_NOT_EQUAL(NULL, path_node);
246     lv_svg_node_t * anim_node = LV_SVG_NODE_CHILD(path_node, 0);
247     TEST_ASSERT_NOT_EQUAL(NULL, anim_node);
248     TEST_ASSERT_EQUAL(LV_SVG_TAG_ANIMATE_COLOR, anim_node->type);
249 
250     lv_svg_attr_type_t at = (LV_ARRAY_GET(&anim_node->attrs, 0, lv_svg_attr_t))->value.ival;
251     TEST_ASSERT_EQUAL(LV_SVG_ATTR_FILL, at);
252 
253     uint32_t c = (LV_ARRAY_GET(&anim_node->attrs, 1, lv_svg_attr_t))->value.uval;
254     TEST_ASSERT_EQUAL(c, 0xFF0000);
255 
256     c = (LV_ARRAY_GET(&anim_node->attrs, 2, lv_svg_attr_t))->value.uval;
257     TEST_ASSERT_EQUAL(c, 0xDDDDFF);
258 
259     lv_svg_attr_values_list_t * l = (LV_ARRAY_GET(&anim_node->attrs, 9, lv_svg_attr_t))->value.val;
260     TEST_ASSERT_EQUAL(l->length, 2);
261     uint32_t * pc = (uint32_t *)(&l->data);
262     TEST_ASSERT_EQUAL(pc[0], 0x00FF00);
263     TEST_ASSERT_EQUAL(pc[1], 0x000000);
264 
265     lv_svg_node_delete(svg_node_root);
266 }
267 #endif
268