[dali_2.0.15] Merge branch 'devel/master'
[platform/core/uifw/dali-toolkit.git] / automated-tests / src / dali-toolkit / utc-Dali-Builder.cpp
1 /*
2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17
18 #include <iostream>
19 #include <iterator>
20 #include <vector>
21 #include <algorithm>
22 #include <cstdlib>
23
24 #include <dali-toolkit-test-suite-utils.h>
25 #include <dali-toolkit/devel-api/builder/builder.h>
26 #include <dali-toolkit/devel-api/builder/base64-encoding.h>
27 #include <dali/integration-api/events/touch-event-integ.h>
28 #include <dali-toolkit/dali-toolkit.h>
29 #include <test-button.h>
30 #include <test-animation-data.h>
31 #include <dummy-control.h>
32
33
34 #define STRINGIFY(A)#A
35
36 using namespace Dali;
37 using namespace Toolkit;
38
39 namespace BuilderControlProperty
40 {
41
42 enum
43 {
44   INTEGER_PROPERTY = Toolkit::Control::CONTROL_PROPERTY_END_INDEX + 1,
45   MATRIX3_PROPERTY,
46   MATRIX_PROPERTY,
47   NONE_PROPERTY
48 };
49
50 namespace
51 {
52
53 BaseHandle Create()
54 {
55   return Toolkit::Control::New();
56 }
57
58 int gSetPropertyCalledCount = 0;
59
60 void SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value )
61 {
62   ++gSetPropertyCalledCount;
63 }
64
65 Property::Value GetProperty( BaseObject* object, Property::Index propertyIndex )
66 {
67   return Property::Value();
68 }
69
70 } // unnamed namespace
71
72 // Properties
73 Dali::TypeRegistration typeRegistration( "BuilderControl", typeid( Toolkit::Control ), Create );
74
75 Dali::PropertyRegistration propertyInteger( typeRegistration, "integerProperty", INTEGER_PROPERTY, Property::INTEGER, &SetProperty, &GetProperty );
76 Dali::PropertyRegistration propertyMatrix3( typeRegistration, "matrix3Property", MATRIX3_PROPERTY, Property::MATRIX3, &SetProperty, &GetProperty );
77 Dali::PropertyRegistration propertyMatrix(  typeRegistration, "matrixProperty",  MATRIX_PROPERTY,  Property::MATRIX,  &SetProperty, &GetProperty );
78 Dali::PropertyRegistration propertyNone(    typeRegistration, "noneProperty",    NONE_PROPERTY,    Property::NONE,    &SetProperty, &GetProperty );
79
80 }
81
82 namespace
83 {
84
85 struct BuilderFunctor
86 {
87   BuilderFunctor( bool& called ) : mCalled( called )
88   {
89     mCalled = false;
90   }
91
92   void operator()()
93   {
94     mCalled = true;
95   }
96
97   bool& mCalled;
98 };
99
100 } // namespace
101
102
103
104 void builder_startup(void)
105 {
106   test_return_value = TET_UNDEF;
107 }
108
109 void builder_cleanup(void)
110 {
111   test_return_value = TET_PASS;
112 }
113
114 int UtcDaliBuilderQuitSignal(void)
115 {
116   ToolkitTestApplication application;
117
118   // JSON with a quit event when the actor is touched
119   std::string json(
120       "{"
121          "\"stage\":"
122          "[{"
123            "\"type\": \"Layer\","
124            "\"size\": [100,100,1],"
125            "\"parentOrigin\": \"TOP_LEFT\","
126            "\"anchorPoint\": \"TOP_LEFT\","
127            "\"maximumSize\": [100,100],"
128            "\"orientation\": [10,10,10,10],"
129            "\"clippingBox\": [10,10,10,10],"
130            "\"signals\": [{"
131              "\"name\": \"touched\","
132              "\"action\": \"quit\""
133            "}]"
134          "}]"
135       "}"
136   );
137   Builder builder = Builder::New();
138   builder.LoadFromString( json );
139   builder.AddActors ( application.GetScene().GetRootLayer() );
140
141   // Connect to builder's quit signal
142   bool functorCalled( false );
143   builder.QuitSignal().Connect( &application, BuilderFunctor( functorCalled ) );
144
145   // Render and notify
146   application.SendNotification();
147   application.Render();
148
149   // Emit touch event and check that our quit method is called
150   Integration::TouchEvent touchEvent;
151   Integration::Point point;
152   point.SetState( PointState::DOWN );
153   point.SetScreenPosition( Vector2( 10.0f, 10.0f ) );
154   touchEvent.points.push_back( point );
155   application.ProcessEvent( touchEvent );
156   DALI_TEST_CHECK( functorCalled );
157
158   END_TEST;
159 }
160
161
162 int UtcDaliBuilderAnimationP(void)
163 {
164   ToolkitTestApplication application;
165
166   // JSON with a quit event when the actor is touched
167   std::string json(
168         "{"
169         "   \"constants\":"
170         "   {"
171         "     \"ALPHA_FUNCTION\":\"EASE_IN_OUT\""
172         "   },"
173         "   \"paths\":"
174         "   {"
175         "     \"path0\":"
176         "     {"
177         "       \"points\":[ [-150, -50, 0], [0.0,70.0,0.0], [190.0,-150.0,0.0] ],"
178         "       \"curvature\":0.35"
179         "     }"
180         "   },"
181         "  \"animations\": {"
182         "    \"animate\": {"
183         "      \"loop\": true,"
184         "      \"endAction\": \"BAKE\","
185         "      \"disconnectAction\": \"BAKE\","
186         "      \"properties\":"
187         "      [{"
188         "        \"actor\": \"greeting\","
189         "        \"property\": \"position\","
190         "        \"value\": [300, 300, -1000],"
191         "        \"alphaFunction\": \"{ALPHA_FUNCTION}\","
192         "        \"relative\": true,"
193         "        \"timePeriod\": {"
194         "          \"delay\": 0,"
195         "          \"duration\": 3"
196         "        }"
197         "      },"
198         "       {"
199         "         \"actor\": \"greeting\","
200         "         \"property\": \"visible\","
201         "         \"alphaFunction\": \"LINEAR\","
202         "         \"value\": true"
203         "       },"
204         "       {"
205         "         \"actor\": \"greeting\","
206         "         \"property\": \"sizeWidth\","
207         "         \"alphaFunction\": \"REVERSE\","
208         "         \"value\": 10.0"
209         "       },"
210         "       {"
211         "         \"actor\": \"greeting\","
212         "         \"property\": \"orientation\","
213         "         \"alphaFunction\": \"EASE_IN\","
214         "         \"value\": [10.0,20.0,30.0]"
215         "       },"
216         "       {"
217         "         \"actor\": \"greeting\","
218         "         \"property\": \"orientation\","
219         "         \"alphaFunction\": \"EASE_OUT\","
220         "         \"value\": [0.0, 0.0, 0.0, 1.0]"
221         "       },"
222         "       {"
223         "         \"actor\": \"greeting\","
224         "         \"property\": \"orientation\","
225         "         \"alphaFunction\": \"EASE_IN_OUT\","
226         "         \"value\": [0.0, 0.0, 0.0, 1.0]"
227         "       },"
228         "       {"
229         "         \"actor\": \"greeting\","
230         "         \"property\": \"orientation\","
231         "         \"alphaFunction\": \"EASE_IN_SINE\","
232         "         \"value\": [0.0, 0.0, 0.0, 1.0]"
233         "       },"
234         "       {"
235         "         \"actor\": \"greeting\","
236         "         \"property\": \"orientation\","
237         "         \"alphaFunction\": \"EASE_OUT_SINE\","
238         "         \"value\": [0.0, 0.0, 0.0, 1.0]"
239         "       },"
240         "       {"
241         "         \"actor\": \"greeting\","
242         "         \"property\": \"orientation\","
243         "         \"alphaFunction\": \"EASE_IN_OUT_SINE\","
244         "         \"value\": [0.0, 0.0, 0.0, 1.0]"
245         "       },"
246         "       {"
247         "         \"actor\": \"greeting\","
248         "         \"property\": \"orientation\","
249         "         \"alphaFunction\": \"BOUNCE\","
250         "         \"value\": [0.0, 0.0, 0.0, 1.0]"
251         "       },"
252         "       {"
253         "         \"actor\": \"greeting\","
254         "         \"property\": \"orientation\","
255         "         \"alphaFunction\": \"SIN\","
256         "         \"value\": [0.0, 0.0, 0.0, 1.0]"
257         "       },"
258         "       {"
259         "         \"actor\": \"greeting\","
260         "         \"property\": \"orientation\","
261         "         \"alphaFunction\": \"EASE_OUT_BACK\","
262         "         \"value\": [0.0, 0.0, 0.0, 1.0]"
263         "       }"
264         "      ]"
265         "    },"
266         "    \"pathAnimation\": {"
267         "      \"duration\": 3.0,"
268         "      \"endAction\": \"DISCARD\","
269         "      \"disconnectAction\": \"BAKE_FINAL\","
270         "      \"properties\": [{"
271         "        \"actor\": \"greeting\","
272         "        \"path\":\"path0\","
273         "        \"forward\":[1,0,0],"
274         "        \"alphaFunction\": \"EASE_IN_OUT\","
275         "        \"timePeriod\": {"
276         "          \"delay\": 0,"
277         "          \"duration\": 3"
278         "        }"
279         "      }]"
280         "    },"
281         "    \"pathAnimation2\": {"
282         "      \"duration\": 3.0,"
283         "      \"endAction\": \"BAKE_FINAL\","
284         "      \"disconnectAction\": \"DISCARD\","
285         "      \"properties\": [{"
286         "        \"actor\": \"greeting\","
287         "        \"path\":\"path0\","
288         "        \"forward\":[1,0,0],"
289         "        \"alphaFunction\": \"EASE_IN_OUT\","
290         "        \"timePeriod\": {"
291         "          \"delay\": 0,"
292         "          \"duration\": 3"
293         "        }"
294         "      }]"
295         "    }"
296         "  },"
297         "  \"stage\": [{"
298         "    \"name\": \"greeting\","
299         "    \"type\": \"TextLabel\","
300         "    \"text\": \"Touch me\","
301         "    \"inherit\": [\"basicText\"],"
302         "    \"position\": [0, -120, 0],"
303         "    \"size\": [200, 200, 1],"
304         "    \"orientation\": [0, 0, 30],"
305         "    \"signals\": [{"
306         "      \"name\": \"touched\","
307         "      \"action\": \"play\","
308         "      \"animation\": \"animate\""
309         "    }]"
310         "  }]"
311         "}");
312
313   Builder builder = Builder::New();
314   builder.LoadFromString( json );
315   builder.AddActors( application.GetScene().GetRootLayer() );
316
317   Animation anim = builder.CreateAnimation("animate");
318
319   DALI_TEST_CHECK( anim );
320
321   Property::Map map;
322   map["ALPHA_FUNCTION"] = "EASE_IN_SQUARE";
323   anim = builder.CreateAnimation("animate", map);
324
325   DALI_TEST_CHECK( anim );
326
327   anim = builder.CreateAnimation("pathAnimation");
328
329   DALI_TEST_CHECK( anim );
330
331   anim = builder.CreateAnimation("pathAnimation2");
332
333   DALI_TEST_CHECK( anim );
334
335   // trigger play
336   // Emit touch event and check that our quit method is called
337   Integration::TouchEvent touchEvent;
338   Integration::Point point;
339   point.SetState( PointState::DOWN );
340   point.SetScreenPosition( Vector2( 10.0f, 10.0f ) );
341   touchEvent.points.push_back( point );
342   application.ProcessEvent( touchEvent );
343
344   // Render and notify
345   application.SendNotification();
346   application.Render();
347
348
349   END_TEST;
350 }
351
352 int UtcDaliBuilderAnimationN(void)
353 {
354   ToolkitTestApplication application;
355
356   // JSON with a quit event when the actor is touched
357   std::string json(
358         "{"
359         "   \"constants\":"
360         "   {"
361         "     \"TEXT\": \"Touch Me\","
362         "     \"NAME\": \"greeting\" "
363         "   },"
364         "   \"paths\":"
365         "   {"
366         "     \"path0\":"
367         "     {"
368         "       \"points\":[ [-150, -50, 0], [0.0,70.0,0.0], [190.0,-150.0,0.0] ],"
369         "       \"curvature\":0.35"
370         "     }"
371         "   },"
372         "  \"animations\": {"
373         "    \"animate\": {"
374         "      \"loop\": true,"
375         "      \"endAction\": \"BAKE\","
376         "      \"disconnectAction\": \"BAKE\","
377         "      \"properties\":"
378         "      [{"
379         "        \"actor\": \"{NAME}\","
380         "        \"property\": \"positioninvalid\","
381         "        \"value\": [300, 300, -1000],"
382         "        \"alphaFunction\": \"EASE_IN_OUT\","
383         "        \"relative\": true,"
384         "        \"timePeriod\": {"
385         "          \"delay\": 0,"
386         "          \"duration\": 3"
387         "        }"
388         "      }"
389         "      ]"
390         "    },"
391         "    \"animate2\": {"
392         "      \"loop\": true,"
393         "      \"endAction\": \"BAKE\","
394         "      \"disconnectAction\": \"BAKE\","
395         "      \"properties\":"
396         "      [{"
397         "        \"actor\": \"{NAME}\","
398         "        \"property\": \"positioninvalid\","
399         "        \"value\": [300, 300, -1000],"
400         "        \"alphaFunction\": \"EGGS_OVER_EASY\","
401         "        \"relative\": true,"
402         "        \"timePeriod\": {"
403         "          \"delay\": 0,"
404         "          \"duration\": 3"
405         "        }"
406         "      }"
407         "      ]"
408         "    },"
409         "    \"pathAnimation\": {"
410         "      \"duration\": 3.0,"
411         "      \"endAction\": \"DISCARD\","
412         "      \"disconnectAction\": \"BAKE_FINAL\","
413         "      \"properties\": [{"
414         "        \"actor\": \"greeting\","
415         "        \"path\":\"pathDoesntExist\","
416         "        \"forward\":[1,0,0],"
417         "        \"alphaFunction\": \"EASE_IN_OUT\","
418         "        \"timePeriod\": {"
419         "          \"delay\": 0,"
420         "          \"duration\": 3"
421         "        }"
422         "      }]"
423         "    }"
424         "  },"
425         "  \"stage\": [{"
426         "    \"name\": \"greeting\","
427         "    \"type\": \"TextLabel\","
428         "    \"text\": \"Touch me\","
429         "    \"inherit\": [\"basicText\"],"
430         "    \"position\": [0, -120, 0],"
431         "    \"size\": [200, 200, 1],"
432         "    \"orientation\": [0, 0, 30],"
433         "    \"signals\": [{"
434         "      \"name\": \"touched\","
435         "      \"action\": \"play\","
436         "      \"animation\": \"animate\""
437         "    }]"
438         "  },"
439         "  {"
440         "    \"name\": \"greeting2\","
441         "    \"type\": \"TextLabel\","
442         "    \"text\": \"Touch me\""
443         "  }]"
444         "}");
445
446
447   Builder builder = Builder::New();
448   builder.LoadFromString( json );
449   builder.AddActors( application.GetScene().GetRootLayer() );
450
451   Animation anim = builder.CreateAnimation("animate");
452
453   // log warning line coverage
454   anim = builder.CreateAnimation("pathAnimation");
455   DALI_TEST_CHECK(anim);
456
457   anim = builder.CreateAnimation("animate");
458   DALI_TEST_CHECK(anim);
459
460   anim = builder.CreateAnimation("animate2");
461   DALI_TEST_CHECK(anim);
462
463   // create referencing a different actor aka animation templates
464   Property::Map map;
465   map["NAME"] = "greeting2";
466   anim = builder.CreateAnimation("animate2", map);
467   DALI_TEST_CHECK(anim);
468
469   // alternative actor to use for FindChildByName
470   anim = builder.CreateAnimation("animate2", application.GetScene().GetRootLayer());
471   DALI_TEST_CHECK(anim);
472
473   // alternative actor to use for FindChildByName
474   anim = builder.CreateAnimation("animate2", map, application.GetScene().GetRootLayer());
475   DALI_TEST_CHECK(anim);
476
477
478   END_TEST;
479
480 }
481
482 int UtcDaliBuilderConstantsP(void)
483 {
484   ToolkitTestApplication application;
485
486   // JSON with a quit event when the actor is touched
487   std::string json(
488       "{"
489       "\"constants\":"
490       "{"
491       "  \"IMAGE_PATH\": \"apath\","
492       "  \"WIDTH\": 22.3,"
493       "  \"ANCHOR\": \"TOP_LEFT\","
494       "  \"PADDING\": [1,2,3,4]"
495       "},"
496       "\"stage\":"
497       "[{"
498       "  \"type\": \"ImageView\","
499       "  \"name\": \"{NAME}\","
500       "  \"size\": [100,100,1],"
501       "  \"parentOrigin\": \"TOP_LEFT\","
502       "  \"anchorPoint\": \"{ANCHOR}\","
503       "  \"padding\": \"{PADDING}\","
504       "  \"image\": { \"url\": \"dir/{IMAGE_PATH}\" },"
505       "  \"sizeWidth\": \"{WIDTH}\","
506       "  \"signals\": [{"
507       "    \"name\": \"touched\","
508       "    \"action\": \"quit\""
509       "  }]"
510       "}]"
511       "}"
512   );
513
514   Builder builder = Builder::New();
515   builder.LoadFromString( json );
516
517   builder.AddConstant( "NAME", "image" );
518
519   Property::Map map = builder.GetConstants();
520
521   Dali::Property::Value* pValue = map.Find( "NAME" );
522
523   DALI_TEST_CHECK( pValue );
524
525   pValue = map.Find( "IMAGE_PATH" );
526
527   DALI_TEST_CHECK( pValue );
528
529   Dali::Property::Value value = builder.GetConstant( "WIDTH" );
530
531   DALI_TEST_CHECK( value.GetType() != Property::NONE );
532
533   builder.AddActors ( application.GetScene().GetRootLayer() );
534   DALI_TEST_CHECK( builder );
535
536   Actor actor = application.GetScene().GetRootLayer().FindChildByName("image");
537   DALI_TEST_CHECK( actor );
538
539   END_TEST;
540 }
541
542 int UtcDaliBuilderTemplatesAndStylesP(void)
543 {
544   ToolkitTestApplication application;
545
546   // JSON with a quit event when the actor is touched
547   std::string json(
548       "{\n"
549       "\"constants\":"
550       "{"
551       "  \"SIZE\": [10,20,30]"
552       "},"
553       "\"styles\":\n"
554       "{\n"
555       "  \"imageStyle\": \n"
556       "  {\n"
557       "    \"color\": [1,0,0,1],\n"
558       "    \"actors\": {\n"
559       "      \"childImage\": {\n"
560       "        \"color\": \"34\"\n"
561       "      }\n"
562       "    }\n"
563       "  }\n"
564       "},\n"
565       "\"templates\":\n"
566       "{\n"
567       "  \"imageViewTemplate\": { \n"
568       "    \"type\": \"ImageView\",\n"
569       "    \"styles\": [\"imageStyle\"]\n"
570       "  },\n"
571       "  \"imageTree\": { \n"
572       "    \"type\": \"ImageView\",\n"
573       "    \"styles\": [\"imageStyle\"],\n"
574       "    \"name\": \"image\",\n"
575       "    \"size\": \"{SIZE}\",\n"
576       "    \"signals\": [{\n"
577       "      \"name\": \"touched\",\n"
578       "      \"action\": \"quit\"\n"
579       "    }],\n"
580       "    \"actors\": [\n"
581       "      {\n"
582       "        \"type\":\"ImageView\",\n"
583       "        \"name\":\"childImage\", \n"
584       "        \"color\": \n"
585       "          {\n"
586       "            \"r\": 10,\n"
587       "            \"g\": 10,\n"
588       "            \"b\": 10,\n"
589       "            \"a\": 100\n"
590       "          }\n"
591       "      },\n"
592       "      {\n"
593       "        \"type\":\"imageViewTemplate\",\n"
594       "        \"name\":\"childImage2\"\n"
595       "      }\n"
596       "    ]\n"
597       "  }\n"
598       "},\n"
599       "\"stage\":"
600       "[{"
601       "  \"type\": \"imageTree\","
602       "  \"size\": [100,100,1]"
603       "}]"
604       "}\n"
605   );
606
607   std::string stylejson(
608     "{\n"
609     " \"color\": [1,0,0,1],\n"
610     " \"actors\": {\n"
611     "   \"childImage\": {\n"
612     "     \"color\": \"#344353\"\n"
613     "   }\n"
614     " }\n"
615     "}\n"
616     );
617
618   std::string templatejson(
619     "{ \n"
620     "  \"type\": \"ImageView\",\n"
621     "  \"styles\": [\"imageStyle\"],\n"
622     "  \"name\": \"image\",\n"
623     "  \"size\": \"{SIZE}\",\n"
624     "  \"signals\": [{\n"
625     "    \"name\": \"touched\",\n"
626     "    \"action\": \"quit\"\n"
627     "  }],\n"
628     "  \"actors\": [\n"
629     "    {\n"
630     "      \"type\":\"ImageView\",\n"
631     "      \"name\":\"childImage\" \n"
632     "    }\n"
633     "  ]\n"
634     "}\n"
635     );
636
637   Builder builder = Builder::New();
638   builder.LoadFromString( json );
639
640   ImageView actor = ImageView::DownCast( builder.Create( "imageTree" ) );
641   DALI_TEST_CHECK( actor );
642
643   Dali::Property::Map map;
644   map["SIZE"] = Vector3(100,100,1);
645   actor = ImageView::DownCast( builder.Create( "imageTree",  map ) );
646   DALI_TEST_CHECK( actor );
647
648   // create from json snippet
649   actor = ImageView::DownCast( builder.CreateFromJson( templatejson ) );
650   DALI_TEST_CHECK( actor );
651
652
653   // NB: already applied in create
654   DALI_TEST_CHECK( builder.ApplyStyle( "imageStyle",  actor ) );
655
656   // apply from json snippet
657   DALI_TEST_CHECK( builder.ApplyFromJson( actor, stylejson ) );
658
659   END_TEST;
660 }
661
662 int UtcDaliBuilderRenderTasksP(void)
663 {
664   ToolkitTestApplication application;
665
666   // JSON with a quit event when the actor is touched
667   std::string json(
668       "{\n"
669       "\"renderTasks\":\n"
670       "{\n"
671       "  \"task0\": {\n"
672       "    \"sourceActor\": \"image\",\n"
673       "    \"cameraActor\": \"camera\" \n"
674       "  }\n"
675       "},\n"
676       "\"stage\":\n"
677       "[\n"
678       "  { \n"
679       "    \"type\": \"CameraActor\",\n"
680       "    \"name\": \"camera\"\n"
681       "  }, \n"
682       "  { \n"
683       "    \"type\": \"ImageView\",\n"
684       "    \"name\": \"image\",\n"
685       "    \"size\": [100,100,1],\n"
686       "    \"signals\": [{\n"
687       "      \"name\": \"touched\",\n"
688       "      \"action\": \"quit\"\n"
689       "    }],\n"
690       "    \"actors\": [\n"
691       "      {\n"
692       "        \"type\":\"ImageView\",\n"
693       "        \"name\":\"childImage\" \n"
694       "      }\n"
695       "    ]\n"
696       "  }\n"
697       "]\n"
698       "}\n"
699   );
700
701   Builder builder = Builder::New();
702   builder.LoadFromString( json );
703
704   unsigned int count = application.GetScene().GetRenderTaskList().GetTaskCount();
705
706   // coverage
707   builder.CreateRenderTask( "task0" );
708
709   DALI_TEST_CHECK( count <
710                    application.GetScene().GetRenderTaskList().GetTaskCount() );
711
712   END_TEST;
713 }
714
715 int UtcDaliBuilderChildActionP(void)
716 {
717   ToolkitTestApplication application;
718
719   // JSON with a quit event when the actor is touched
720   std::string json(
721       "{\n"
722       "  \"stage\":\n"
723       "  [{\n"
724       "    \"type\": \"Actor\",\n"
725       "    \"name\": \"actor\",\n"
726       "    \"size\": [100,100,1],\n"
727       "    \"parentOrigin\": \"TOP_LEFT\",\n"
728       "    \"anchorPoint\": \"TOP_LEFT\",\n"
729       "    \"actors\": [{\n"
730       "      \"type\": \"Actor\",\n"
731       "      \"name\": \"subActor\"\n"
732       "    }],\n"
733       "    \"signals\": [{\n"
734       "      \"name\": \"touched\",\n"
735       "      \"action\": \"hide\",\n"
736       "      \"actor\": \"actor\",\n"
737       "      \"childActor\": \"subActor\"\n"
738       "    }]\n"
739       "  }]\n"
740       "}\n"
741   );
742
743   Builder builder = Builder::New();
744   builder.LoadFromString( json );
745   builder.AddActors ( application.GetScene().GetRootLayer() );
746
747   // Render and notify
748   application.SendNotification();
749   application.Render();
750
751   // Emit touch event and check that our quit method is called
752   Integration::TouchEvent touchEvent;
753   Integration::Point point;
754   point.SetState( PointState::DOWN );
755   point.SetScreenPosition( Vector2( 10.0f, 10.0f ) );
756   touchEvent.points.push_back( point );
757   application.ProcessEvent( touchEvent );
758
759   // Render and notify
760   application.SendNotification();
761   application.Render();
762
763   Actor actor = application.GetScene().GetRootLayer().FindChildByName("subActor");
764   DALI_TEST_CHECK( actor );
765
766   DALI_TEST_CHECK( !actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) );
767
768   END_TEST;
769 }
770
771 int UtcDaliBuilderSetPropertyActionP(void)
772 {
773   ToolkitTestApplication application;
774
775   // JSON with a quit event when the actor is touched
776   std::string json(
777       "{\n"
778       "  \"stage\":\n"
779       "  [{\n"
780       "    \"type\": \"Actor\",\n"
781       "    \"name\": \"actor\",\n"
782       "    \"size\": [100,100,1],\n"
783       "    \"parentOrigin\": \"TOP_LEFT\",\n"
784       "    \"anchorPoint\": \"TOP_LEFT\",\n"
785       "    \"actors\": [{\n"
786       "      \"type\": \"Actor\",\n"
787       "      \"name\": \"subActor\"\n"
788       "    }],\n"
789       "    \"signals\": [{\n"
790       "      \"name\": \"touched\",\n"
791       "      \"action\": \"set\",\n"
792       "      \"actor\": \"subActor\",\n"
793       "      \"property\": \"visible\",\n"
794       "      \"value\": false\n"
795       "    }]\n"
796       "  }]\n"
797       "}\n"
798   );
799
800   Builder builder = Builder::New();
801   builder.LoadFromString( json );
802   builder.AddActors ( application.GetScene().GetRootLayer() );
803
804   // Render and notify
805   application.SendNotification();
806   application.Render();
807
808   // Emit touch event and check that our quit method is called
809   Integration::TouchEvent touchEvent;
810   Integration::Point point;
811   point.SetState( PointState::DOWN );
812   point.SetScreenPosition( Vector2( 10.0f, 10.0f ) );
813   touchEvent.points.push_back( point );
814   application.ProcessEvent( touchEvent );
815
816   // Render and notify
817   application.SendNotification();
818   application.Render();
819
820   Actor actor = application.GetScene().GetRootLayer().FindChildByName("subActor");
821   DALI_TEST_CHECK( actor );
822
823   DALI_TEST_CHECK( !actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) );
824
825   END_TEST;
826 }
827
828 int UtcDaliBuilderGenericActionP(void)
829 {
830   ToolkitTestApplication application;
831
832   // JSON with a quit event when the actor is touched
833   std::string json(
834       "{\n"
835       "  \"stage\":\n"
836       "  [{\n"
837       "    \"type\": \"Actor\",\n"
838       "    \"name\": \"actor\",\n"
839       "    \"size\": [100,100,1],\n"
840       "    \"parentOrigin\": \"TOP_LEFT\",\n"
841       "    \"anchorPoint\": \"TOP_LEFT\",\n"
842       "    \"actors\": [{\n"
843       "      \"type\": \"Actor\",\n"
844       "      \"name\": \"subActor\"\n"
845       "    }],\n"
846       "    \"signals\": [{\n"
847       "      \"name\": \"touched\",\n"
848       "      \"action\": \"hide\"\n"
849       "    }]\n"
850       "  }]\n"
851       "}\n"
852   );
853
854   Builder builder = Builder::New();
855   builder.LoadFromString( json );
856   builder.AddActors ( application.GetScene().GetRootLayer() );
857
858   // Render and notify
859   application.SendNotification();
860   application.Render();
861
862   // Emit touch event and check that our quit method is called
863   Integration::TouchEvent touchEvent;
864   Integration::Point point;
865   point.SetState( PointState::DOWN );
866   point.SetScreenPosition( Vector2( 10.0f, 10.0f ) );
867   touchEvent.points.push_back( point );
868   application.ProcessEvent( touchEvent );
869
870   // Render and notify
871   application.SendNotification();
872   application.Render();
873
874   Actor actor = application.GetScene().GetRootLayer().FindChildByName("actor");
875   DALI_TEST_CHECK( actor );
876
877   DALI_TEST_CHECK( !actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) );
878
879   END_TEST;
880 }
881
882 int UtcDaliBuilderPropertyNotificationP(void)
883 {
884   ToolkitTestApplication application;
885
886   // JSON with a quit event when the actor is touched
887   std::string json(
888       "{\n"
889       "  \"stage\":\n"
890       "  [{\n"
891       "    \"type\": \"Actor\",\n"
892       "    \"name\": \"actor\",\n"
893       "    \"size\": [100,100,1],\n"
894       "    \"parentOrigin\": \"TOP_LEFT\",\n"
895       "    \"anchorPoint\": \"TOP_LEFT\",\n"
896       "    \"actors\": [{\n"
897       "      \"type\": \"Actor\",\n"
898       "      \"name\": \"subActor\"\n"
899       "    }],\n"
900       "    \"signals\": [{\n"
901       "      \"name\": \"touched\",\n"
902       "      \"action\": \"hide\"\n"
903       "    }],\n"
904       "    \"notifications\": [{\n"
905       "      \"property\": \"visible\",\n"
906       "      \"condition\": \"False\",\n"
907       "      \"action\": \"show\"\n"
908       "    },\n"
909       "    {\n"
910       "      \"property\": \"positionX\",\n"
911       "      \"condition\": \"LessThan\",\n"
912       "      \"arg0\": 0.0,\n"
913       "      \"action\": \"show\"\n"
914       "    },\n"
915       "    {\n"
916       "      \"property\": \"positionY\",\n"
917       "      \"condition\": \"GreaterThan\",\n"
918       "      \"arg0\": 200.0,\n"
919       "      \"action\": \"show\"\n"
920       "    },\n"
921       "    {\n"
922       "      \"property\": \"positionZ\",\n"
923       "      \"condition\": \"Inside\",\n"
924       "      \"arg0\": 0.0,\n"
925       "      \"arg1\": 10.0,\n"
926       "      \"action\": \"show\"\n"
927       "    },\n"
928       "    {\n"
929       "      \"property\": \"positionZ\",\n"
930       "      \"condition\": \"Outside\",\n"
931       "      \"arg0\": 40.0,\n"
932       "      \"arg1\": 50.0,\n"
933       "      \"action\": \"show\"\n"
934       "    }]\n"
935       "  }]\n"
936       "}\n"
937   );
938
939   Builder builder = Builder::New();
940   builder.LoadFromString( json );
941   builder.AddActors ( application.GetScene().GetRootLayer() );
942
943   // Render and notify
944   application.SendNotification();
945   application.Render();
946
947   // Emit touch event and check that our quit method is called
948   Integration::TouchEvent touchEvent;
949   Integration::Point point;
950   point.SetState( PointState::DOWN );
951   point.SetScreenPosition( Vector2( 10.0f, 10.0f ) );
952   touchEvent.points.push_back( point );
953   application.ProcessEvent( touchEvent );
954
955   // Render and notify
956   application.SendNotification();
957   application.Render();
958
959   // Render and notify
960   application.SendNotification();
961   application.Render();
962
963   Actor actor = application.GetScene().GetRootLayer().FindChildByName("actor");
964   DALI_TEST_CHECK( actor );
965
966   DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) );
967
968   END_TEST;
969 }
970
971 int UtcDaliBuilderPropertyNotificationN(void)
972 {
973   ToolkitTestApplication application;
974
975   // JSON with a quit event when the actor is touched
976   std::string json(
977       "{\n"
978       "  \"stage\":\n"
979       "  [{\n"
980       "    \"type\": \"Actor\",\n"
981       "    \"notifications\": [{\n"
982       "      \"property\": \"visible\",\n"
983       "      \"condition\": \"ErrorCondition\",\n"
984       "      \"action\": \"show\"\n"
985       "    }]\n"
986       "  }]\n"
987       "}\n"
988   );
989
990   try
991   {
992     Builder builder = Builder::New();
993     builder.LoadFromString( json );
994     builder.AddActors ( application.GetScene().GetRootLayer() );
995     DALI_TEST_CHECK( false );
996   }
997   catch(...)
998   {
999     DALI_TEST_CHECK( true );
1000   }
1001
1002   END_TEST;
1003 }
1004
1005
1006
1007 int UtcDaliBuilderCustomPropertyP(void)
1008 {
1009   ToolkitTestApplication application;
1010
1011   // JSON with a quit event when the actor is touched
1012   std::string json(
1013       "{\n"
1014       "\"templates\":\n"
1015       "{\n"
1016       "  \"imageTree\": { \n"
1017       "    \"type\": \"ImageView\",\n"
1018       "    \"name\": \"image\",\n"
1019       "    \"size\": [100,100,1],\n"
1020       "    \"signals\": [{\n"
1021       "      \"name\": \"touched\",\n"
1022       "      \"action\": \"quit\"\n"
1023       "    }],\n"
1024       "    \"properties\": {\n"
1025       "      \"newproperty\": true\n"
1026       "    },\n"
1027       "    \"animatableProperties\": {\n"
1028       "      \"newAnimatableproperty\": 3\n"
1029       "    },\n"
1030       "    \"actors\": [\n"
1031       "      {\n"
1032       "        \"type\":\"ImageView\",\n"
1033       "        \"name\":\"childImage\" \n"
1034       "      }\n"
1035       "    ]\n"
1036       "  }\n"
1037       "}\n"
1038       "}\n"
1039   );
1040
1041   Builder builder = Builder::New();
1042   builder.LoadFromString( json );
1043
1044   ImageView actor = ImageView::DownCast( builder.Create( "imageTree" ) );
1045   DALI_TEST_CHECK( actor );
1046
1047   // NB: already applied in create
1048   Property::Index index = actor.GetPropertyIndex("newproperty");
1049   DALI_TEST_CHECK( Property::INVALID_INDEX != index );
1050   Property::Value value = actor.GetProperty(index);
1051   DALI_TEST_CHECK( value.Get<bool>() == true );
1052
1053   index = actor.GetPropertyIndex("newAnimatableproperty");
1054   DALI_TEST_CHECK( Property::INVALID_INDEX != index );
1055   value = actor.GetProperty(index);
1056   DALI_TEST_CHECK( value.Get<int>() == 3 );
1057
1058   END_TEST;
1059 }
1060
1061 int UtcDaliBuilderCustomShaderP(void)
1062 {
1063   ToolkitTestApplication application;
1064
1065   // JSON with a quit event when the actor is touched
1066   std::string json(
1067     "{\n"
1068     "  \"stage\": [\n"
1069     "    {\n"
1070     "      \"type\": \"ImageView\",\n"
1071     "      \"name\": \"Image1\",\n"
1072     "      \"position\": [\n"
1073     "        0.40461349487305,\n"
1074     "        0.9150390625,\n"
1075     "        0.0\n"
1076     "      ],\n"
1077     "      \"parentOrigin\": [0.5, 0.5, 0.5],\n"
1078     "      \"size\": [200, 200, 0],\n"
1079     "      \"effect\": \"Ripple2D\",\n"
1080     "      \"image\": {\n"
1081     "        \"url\": \"{DALI_IMAGE_DIR}gallery-medium-25.jpg\",\n"
1082     "        \"desiredWidth\": 200,\n"
1083     "        \"desiredHeight\": 80,\n"
1084     "        \"shader\": {\n"
1085     "           \"fragmentShader\": \"precision mediump float;\\nuniform sampler2D sTexture;\\nuniform vec4 uColor;\\nuniform float uAmplitude;\\nuniform float uTime;\\nvarying vec2 vTexCoord;\\nvoid main()\\n{\\n  highp vec2 pos = -1.0 + 2.0 * vTexCoord;\\n  highp float len = length(pos);\\n  highp vec2 texCoord = vTexCoord + pos/len * sin( len * 12.0 - uTime * 4.0 ) * uAmplitude;\\n  gl_FragColor = texture2D(sTexture, texCoord) * uColor;}\\n\\n\"\n"
1086     "        }\n"
1087     "      },\n"
1088     "      \"customAnimatableProperties\": {\n"
1089     "         \"uAmplitude\": 0.02,\n"
1090     "         \"uTime\": 0.0\n"
1091     "      },\n"
1092     "      \"signals\": [\n"
1093     "        {\n"
1094     "          \"name\": \"onScene\",\n"
1095     "          \"action\": \"play\",\n"
1096     "          \"animation\": \"Animation_1\"\n"
1097     "        }\n"
1098     "      ]\n"
1099     "    }\n"
1100     "  ],\n"
1101     "  \"animations\": {\n"
1102     "    \"Animation_1\": {\n"
1103     "      \"loop\":true,\n"
1104     "      \"properties\": [\n"
1105     "        {\n"
1106     "          \"actor\": \"Image1\",\n"
1107     "          \"property\": \"uTime\",\n"
1108     "          \"value\": 10.0,\n"
1109     "          \"alphaFunction\": \"LINEAR\",\n"
1110     "          \"timePeriod\": {\n"
1111     "            \"delay\": 0,\n"
1112     "            \"duration\": 10.0\n"
1113     "          }\n"
1114     "        }\n"
1115     "      ]\n"
1116     "    }\n"
1117     "  }\n"
1118     "}\n"
1119
1120   );
1121
1122   Builder builder = Builder::New();
1123   builder.LoadFromString( json );
1124
1125   builder.AddActors ( "stage", application.GetScene().GetRootLayer() );
1126
1127   // Render and notify
1128   application.SendNotification();
1129   application.Render();
1130
1131   Actor actor = application.GetScene().GetRootLayer().FindChildByName("Image1");
1132
1133   // coverage
1134   DALI_TEST_CHECK( actor );
1135
1136   END_TEST;
1137 }
1138
1139
1140 int UtcDaliBuilderLoadFromStringN(void)
1141 {
1142   ToolkitTestApplication application;
1143
1144   // JSON with a quit event when the actor is touched
1145   std::string json(
1146       "asdfsadf dsf asdf asdf {"
1147          "\"stage\":"
1148          "[{"
1149            "\"type\": \"Actor\","
1150            "\"size\": [100,100,1],"
1151            "\"parentOrigin\": \"TOP_LEFT\","
1152            "\"anchorPoint\": \"TOP_LEFT\","
1153            "\"signals\": [{"
1154              "\"name\": \"touched\","
1155              "\"action\": \"quit\""
1156            "}]"
1157          "}]"
1158       "}"
1159   );
1160   Builder builder = Builder::New();
1161
1162   bool assert1 = false;
1163
1164   try
1165   {
1166     builder.LoadFromString( json );
1167   }
1168   catch( Dali::DaliException& e )
1169   {
1170     DALI_TEST_PRINT_ASSERT( e );
1171     DALI_TEST_EQUALS(e.condition, "!\"Cannot parse JSON\"", TEST_LOCATION);
1172     assert1 = true;
1173   }
1174
1175   DALI_TEST_CHECK( assert1 );
1176
1177   END_TEST;
1178 }
1179
1180
1181 int UtcDaliBuilderAddActorsP(void)
1182 {
1183   ToolkitTestApplication application;
1184
1185   // JSON with a quit event when the actor is touched
1186   std::string json(
1187       "{\n"
1188       "  \"arbitarysection\":\n"
1189       "  [{\n"
1190       "    \"type\": \"Actor\",\n"
1191       "    \"name\": \"actor\",\n"
1192       "    \"size\": [100,100,1],\n"
1193       "    \"parentOrigin\": \"TOP_LEFT\",\n"
1194       "    \"anchorPoint\": \"TOP_LEFT\",\n"
1195       "    \"actors\": [{\n"
1196       "      \"type\": \"Actor\",\n"
1197       "      \"name\": \"subActor\",\n"
1198       "      \"visible\": false\n"
1199       "    }],\n"
1200       "    \"signals\": [{\n"
1201       "      \"name\": \"touched\",\n"
1202       "      \"action\": \"hide\",\n"
1203       "      \"actor\": \"actor\",\n"
1204       "      \"childActor\": \"subActor\"\n"
1205       "    }]\n"
1206       "  }]\n"
1207       "}\n"
1208   );
1209
1210   Builder builder = Builder::New();
1211   builder.LoadFromString( json );
1212   builder.AddActors ( "arbitarysection", application.GetScene().GetRootLayer() );
1213
1214   // Render and notify
1215   application.SendNotification();
1216   application.Render();
1217
1218   Actor actor = application.GetScene().GetRootLayer().FindChildByName("subActor");
1219   DALI_TEST_CHECK( actor );
1220
1221   DALI_TEST_CHECK( !actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) );
1222
1223   END_TEST;
1224 }
1225
1226 int UtcDaliBuilderPathConstraintsP(void)
1227 {
1228   ToolkitTestApplication application;
1229
1230   // JSON with a quit event when the actor is touched
1231   std::string json(
1232     "{\n"
1233     "  \"constants\":\n"
1234     "  {\n"
1235     "    \"FB_WIDTH\": 200.0,\n"
1236     "    \"FB_HEIGHT\": 200.0,\n"
1237     "    \"FB_SIZE\": [200,200],\n"
1238     "    \"FB_ASPECT_RATIO\": 1\n"
1239     "  },\n"
1240     "  \"stage\": [\n"
1241     "    {\n"
1242     "      \"type\": \"ImageView\",\n"
1243     "      \"name\": \"Image1\",\n"
1244     "      \"size\": [200, 200, 0],\n"
1245     "      \"parentOrigin\": [0.5, 0.5, 0.5],\n"
1246     "      \"effect\": \"Ripple2D\",\n"
1247     "      \"image\": {\n"
1248     "        \"url\": \"{DALI_IMAGE_DIR}gallery-medium-25.jpg\"\n"
1249     "      },\n"
1250     "      \"signals\": [\n"
1251     "        {\n"
1252     "          \"name\": \"onScene\",\n"
1253     "          \"action\": \"play\",\n"
1254     "          \"animation\": \"pathAnimation\"\n"
1255     "        },\n"
1256     "        {\n"
1257     "          \"name\": \"onScene\",\n"
1258     "          \"action\": \"applyConstraint\",\n"
1259     "          \"constrainer\": \"constrainer0\",\n"
1260     "          \"properties\":\n"
1261     "          [\n"
1262     "            {\n"
1263     "              \"source\": \"Image1\",\n"
1264     "              \"sourceProperty\": \"positionX\",\n"
1265     "              \"target\": \"Image1\",\n"
1266     "              \"targetProperty\": \"colorRed\",\n"
1267     "              \"range\": [-300,300]\n"
1268     "            }\n"
1269     "          ]\n"
1270     "        },\n"
1271     "        {\n"
1272     "          \"name\": \"onScene\",\n"
1273     "          \"action\": \"applyConstraint\",\n"
1274     "          \"constrainer\": \"constrainer1\",\n"
1275     "          \"properties\":\n"
1276     "          [\n"
1277     "            {\n"
1278     "              \"source\": \"Image1\",\n"
1279     "              \"sourceProperty\": \"positionX\",\n"
1280     "              \"target\": \"Image1\",\n"
1281     "              \"targetProperty\": \"colorBlue\",\n"
1282     "              \"range\": [-300,300]\n"
1283     "            }\n"
1284     "          ]\n"
1285     "        },\n"
1286     "        {\n"
1287     "          \"name\": \"offScene\",\n"
1288     "          \"action\": \"removeConstraints\",\n"
1289     "          \"constrainer\": \"constrainer0\",\n"
1290     "          \"properties\":\n"
1291     "          [\n"
1292     "            {\n"
1293     "              \"source\": \"Image1\",\n"
1294     "              \"sourceProperty\": \"positionX\",\n"
1295     "              \"target\": \"Image1\",\n"
1296     "              \"targetProperty\": \"colorRed\",\n"
1297     "              \"range\": [-300,300]\n"
1298     "            }\n"
1299     "          ]\n"
1300     "        },\n"
1301     "        {\n"
1302     "          \"name\": \"offScene\",\n"
1303     "          \"action\": \"removeConstraints\",\n"
1304     "          \"constrainer\": \"constrainer1\",\n"
1305     "          \"properties\":\n"
1306     "          [\n"
1307     "            {\n"
1308     "              \"source\": \"Image1\",\n"
1309     "              \"sourceProperty\": \"positionX\",\n"
1310     "              \"target\": \"Image1\",\n"
1311     "              \"targetProperty\": \"colorBlue\",\n"
1312     "              \"range\": [-300,300]\n"
1313     "            }\n"
1314     "          ]\n"
1315     "        }\n"
1316     "      ]\n"
1317     "    }\n"
1318     "  ],\n"
1319     "  \"paths\":\n"
1320     "  {\n"
1321     "    \"path0\":\n"
1322     "    {\n"
1323     "      \"points\":[ [-150, -50, 0], [0.0,70.0,0.0], [190.0,-150.0,0.0] ],\n"
1324     "      \"curvature\":0.35\n"
1325     "    }\n"
1326     "  },\n"
1327     "  \"constrainers\":\n"
1328     "  {\n"
1329     "    \"constrainer0\":\n"
1330     "    {\n"
1331     "      \"type\": \"PathConstrainer\",\n"
1332     "      \"points\": [ [0, 0, 0], [0,0,0], [0,0,0] ],\n"
1333     "      \"controlPoints\": [ [0, 0, 0], [0,0,0], [0,0,0] ]\n"
1334     "    },\n"
1335     "    \"constrainer1\":\n"
1336     "    {\n"
1337     "      \"type\": \"LinearConstrainer\",\n"
1338     "      \"value\": [ 0, 0, 0 ]\n"
1339     "    }\n"
1340     "  },\n"
1341     "  \"animations\": {\n"
1342     "    \"pathAnimation\": {\n"
1343     "      \"duration\": 3.0,\n"
1344     "      \"properties\":\n"
1345     "      [{\n"
1346     "        \"actor\": \"Image1\",\n"
1347     "        \"path\":\"path0\",\n"
1348     "        \"forward\":[1,0,0],\n"
1349     "        \"alphaFunction\": \"EASE_IN_OUT\",\n"
1350     "        \"timePeriod\": {\n"
1351     "          \"delay\": 0,\n"
1352     "          \"duration\": 3\n"
1353     "        }\n"
1354     "      },\n"
1355     "       {\n"
1356     "         \"actor\": \"Image1\",\n"
1357     "         \"property\": \"uTime\",\n"
1358     "         \"value\": 10.0,\n"
1359     "         \"alphaFunction\": \"LINEAR\",\n"
1360     "         \"timePeriod\": {\n"
1361     "           \"delay\": 0,\n"
1362     "           \"duration\": 10.0\n"
1363     "         },\n"
1364     "         \"gui-builder-timeline-color\": \"#8dc0da\"\n"
1365     "       }]\n"
1366     "    },\n"
1367     "    \"Animation_1\": {\n"
1368     "      \"loop\":true,\n"
1369     "      \"properties\": [\n"
1370     "        {\n"
1371     "          \"actor\": \"Image1\",\n"
1372     "          \"property\": \"uTime\",\n"
1373     "          \"value\": 10.0,\n"
1374     "          \"alphaFunction\": \"LINEAR\",\n"
1375     "          \"timePeriod\": {\n"
1376     "            \"delay\": 0,\n"
1377     "            \"duration\": 10.0\n"
1378     "          },\n"
1379     "          \"gui-builder-timeline-color\": \"#8dc0da\"\n"
1380     "        }\n"
1381     "      ]\n"
1382     "    }\n"
1383     "  }\n"
1384     "}\n");
1385
1386   Builder builder = Builder::New();
1387
1388   // frame buffer coverage
1389   builder.LoadFromString( json );
1390
1391   // Render and notify
1392   application.SendNotification();
1393   application.Render();
1394
1395   Dali::Path path =  builder.GetPath( "path0" );
1396   DALI_TEST_CHECK( path );
1397
1398   Dali::Path path2 =  builder.GetPath( "path0" );
1399   DALI_TEST_CHECK( path2 );
1400   DALI_TEST_CHECK( path == path2 );
1401
1402   Dali::PathConstrainer constrainer0 = builder.GetPathConstrainer( "constrainer0" );
1403   DALI_TEST_CHECK( constrainer0 );
1404
1405   Dali::PathConstrainer constrainer0_2 = builder.GetPathConstrainer( "constrainer0" );
1406   DALI_TEST_CHECK( constrainer0_2 );
1407   DALI_TEST_CHECK( constrainer0 == constrainer0_2 );
1408
1409   Dali::LinearConstrainer constrainer1 = builder.GetLinearConstrainer( "constrainer1" );
1410   DALI_TEST_CHECK( constrainer1 );
1411
1412   Dali::LinearConstrainer constrainer1_2 = builder.GetLinearConstrainer( "constrainer1" );
1413   DALI_TEST_CHECK( constrainer1 == constrainer1_2 );
1414
1415   // For coverage
1416
1417   Actor actor = Actor::New();
1418   application.GetScene().Add( actor );
1419   builder.AddActors( actor );
1420
1421   // Render and notify
1422   application.SendNotification();
1423   application.Render();
1424
1425   actor.GetChildAt( 0 ).Unparent();
1426
1427   END_TEST;
1428 }
1429
1430 #define CHECK_MAP_ELEMENT( xMap, xKey, xType, xPropType, xExpected, xLocation ) \
1431   {                                                                       \
1432     Property::Value* value = xMap->Find( xKey );                          \
1433     DALI_TEST_EQUALS( value==NULL, false, xLocation);                     \
1434     if( value != NULL )                                                   \
1435     {                                                                     \
1436       DALI_TEST_EQUALS( value->GetType(), xPropType, xLocation );         \
1437       xType result;                                                       \
1438       value->Get(result);                                                 \
1439       DALI_TEST_EQUALS( result, xExpected, TEST_LOCATION );               \
1440       std::ostringstream oss;                                             \
1441       oss << "Animation element " << xKey << "= " << result << std::endl; \
1442       tet_printf( oss.str().c_str() );                                    \
1443     }                                                                     \
1444     else                                                                  \
1445     {                                                                     \
1446       tet_printf("Can't find map element " xKey "\n");                    \
1447     }                                                                     \
1448   }
1449
1450
1451 int UtcDaliBuilderMapping01(void)
1452 {
1453   ToolkitTestApplication application;
1454
1455   const char* json =
1456     "{\n"
1457     "  \"mappings\":\n"
1458     "  {\n"
1459     "    \"buttonPressFadeOut\":{\n"
1460     "      \"alphaFunction\":\"EASE_OUT\",\n"
1461     "      \"timePeriod\":{\n"
1462     "        \"delay\":0.0,\n"
1463     "        \"duration\":0.4\n"
1464     "      }\n"
1465     "    },\n"
1466     "    \"buttonPressFadeIn\":{\n"
1467     "      \"alphaFunction\":\"EASE_IN\",\n"
1468     "      \"timePeriod\":{\n"
1469     "        \"delay\":0.4,\n"
1470     "        \"duration\":0.5\n"
1471     "      }\n"
1472     "    },\n"
1473     "    \"transition:buttonPressed\":\n"
1474     "    [\n"
1475     "      {\n"
1476     "        \"target\": \"unselectedBackgroundRenderer\",\n"
1477     "        \"property\": \"opacity\",\n"
1478     "        \"value\": 0,\n"
1479     "        \"animator\":\"<buttonPressFadeOut>\"\n"
1480     "      }\n"
1481     "    ],\n"
1482     "    \"transition:buttonReleased\":\n"
1483     "    [\n"
1484     "      {\n"
1485     "        \"target\": \"unselectedBackgroundRenderer\",\n"
1486     "        \"property\": \"opacity\",\n"
1487     "        \"value\": 1,\n"
1488     "        \"animator\":\"<buttonPressFadeIn>\"\n"
1489     "      },\n"
1490     "      {\n"
1491     "        \"target\": \"unselectedForegroundRenderer\",\n"
1492     "        \"property\": \"scale\",\n"
1493     "        \"value\": [ 1, 1, 1 ],\n"
1494     "        \"animator\":\"<buttonPressFadeIn>\"\n"
1495     "      },\n"
1496     "      {\n"
1497     "        \"target\": \"selectedBackgroundRenderer\",\n"
1498     "        \"property\": \"opacity\",\n"
1499     "        \"value\": 0,\n"
1500     "        \"animator\": \"<buttonPressFadeOut>\"\n"
1501     "      },\n"
1502     "      {\n"
1503     "        \"target\": \"selectedForegroundRenderer\",\n"
1504     "        \"property\": \"scale\",\n"
1505     "        \"value\": [ 0, 0, 0 ],\n"
1506     "        \"animator\":\"<buttonPressFadeOut>\"\n"
1507     "      }\n"
1508     "    ]\n"
1509     "  },\n"
1510     "  \"styles\":\n"
1511     "  {\n"
1512     "    \"testbutton\":\n"
1513     "    {\n"
1514     "      \"pressTransition\":\"<transition:buttonPressed>\",\n"
1515     "      \"releaseTransition\":\"<transition:buttonReleased>\"\n"
1516     "    }\n"
1517     "  }\n"
1518     "}\n";
1519
1520   Builder builder = Builder::New();
1521   builder.LoadFromString( json );
1522
1523   Test::TestButton testButton = Test::TestButton::New();
1524   application.GetScene().Add( testButton );
1525
1526   // Render and notify
1527   application.SendNotification();
1528   application.Render();
1529
1530   DALI_TEST_CHECK( builder.ApplyStyle( "testbutton", testButton ) );
1531
1532   // Now check that it has loaded the transition correctly:
1533   Property::Value transition = testButton.GetProperty(Test::TestButton::Property::PRESS_TRANSITION);
1534   DALI_TEST_EQUALS( transition.GetType(), Property::ARRAY, TEST_LOCATION );
1535   Property::Array* array = transition.GetArray();
1536
1537   DALI_TEST_EQUALS( array->Size(), 1, TEST_LOCATION );
1538   Property::Value element = array->GetElementAt(0);
1539   DALI_TEST_CHECK( element.GetType() == Property::MAP );
1540   Property::Map* map = element.GetMap();
1541
1542   CHECK_MAP_ELEMENT(map, "target", std::string, Property::STRING, "unselectedBackgroundRenderer", TEST_LOCATION);
1543   CHECK_MAP_ELEMENT(map, "property", std::string, Property::STRING, "opacity", TEST_LOCATION);
1544   CHECK_MAP_ELEMENT(map, "alphaFunction", int, Property::INTEGER, (int)Dali::AlphaFunction::EASE_OUT, TEST_LOCATION);
1545   CHECK_MAP_ELEMENT(map, "timePeriodDelay", float, Property::FLOAT, 0.0f, TEST_LOCATION);
1546   CHECK_MAP_ELEMENT(map, "timePeriodDuration", float, Property::FLOAT, 0.4f, TEST_LOCATION);
1547
1548   END_TEST;
1549 }
1550
1551
1552 int UtcDaliBuilderMappingCycleCheck(void)
1553 {
1554   ToolkitTestApplication application;
1555
1556   std::string json(
1557     "{\n"
1558     "  \"mappings\":\n"
1559     "  {\n"
1560     "    \"cyclicKey1\":\"<cyclicKey1>\",\n"
1561     "    \"cyclicKey2\":\"<cyclicKey3>\",\n"
1562     "    \"cyclicKey3\":\"<cyclicKey2>\",\n"
1563     "    \"FadeOut\":{\n"
1564     "      \"alphaFunction\":\"EASE_IN\",\n"
1565     "      \"timePeriod\":{\n"
1566     "        \"delay\":\"<cyclicKey3>\",\n"
1567     "        \"duration\":0.6\n"
1568     "      }\n"
1569     "    },\n"
1570     "    \"transition:buttonPressed\":\n"
1571     "    [\n"
1572     "      {\n"
1573     "        \"target\": \"<cyclicKey1>\",\n"
1574     "        \"property\": \"<cyclicKey2>\",\n"
1575     "        \"value\": 0,\n"
1576     "        \"animator\":\"<FadeOut>\"\n"
1577     "      }\n"
1578     "    ]\n"
1579     "  },\n"
1580     "  \"styles\":\n"
1581     "  {\n"
1582     "    \"testbutton\":\n"
1583     "    {\n"
1584     "      \"pressTransition\":\"<transition:buttonPressed>\",\n"
1585     "      \"releaseTransition\":\"<cyclicKey2>\",\n"
1586     "      \"disabledTransition\":\"<cyclicKey3>\",\n"
1587     "      \"enabledTransition\":\"<unknownKey>\"\n"
1588     "    }\n"
1589     "  }\n"
1590     "}\n");
1591
1592   Builder builder = Builder::New();
1593   builder.LoadFromString( json );
1594
1595   Test::TestButton testButton = Test::TestButton::New();
1596   application.GetScene().Add( testButton );
1597
1598   // Render and notify
1599   application.SendNotification();
1600   application.Render();
1601
1602   DALI_TEST_CHECK( builder.ApplyStyle( "testbutton", testButton ) );
1603
1604   // Now check that it has loaded the transition correctly:
1605   Property::Value transition = testButton.GetProperty(Test::TestButton::Property::PRESS_TRANSITION);
1606   DALI_TEST_EQUALS( transition.GetType(), Property::ARRAY, TEST_LOCATION );
1607   Property::Array* array = transition.GetArray();
1608
1609   DALI_TEST_EQUALS( array->Size(), 1, TEST_LOCATION );
1610   Property::Value element = array->GetElementAt(0);
1611   DALI_TEST_CHECK( element.GetType() == Property::MAP );
1612   Property::Map* map = element.GetMap();
1613
1614   CHECK_MAP_ELEMENT(map, "target", std::string, Property::STRING, "", TEST_LOCATION);
1615   CHECK_MAP_ELEMENT(map, "property", std::string, Property::STRING, "", TEST_LOCATION);
1616   CHECK_MAP_ELEMENT(map, "timePeriodDuration", float, Property::FLOAT, 0.6f, TEST_LOCATION);
1617
1618   END_TEST;
1619 }
1620
1621 int UtcDaliBuilderTypeCasts(void)
1622 {
1623   ToolkitTestApplication application;
1624
1625   std::string json(
1626     "{"
1627        "\"stage\":"
1628        "[{"
1629          "\"type\": \"Layer\","
1630          "\"maximumSize\": { \"typeCast\":\"vector2\", \"value\":[100,15] },"
1631          "\"position\":    { \"typeCast\":\"vector3\", \"value\":[100,10,1] },"
1632          "\"color\":       { \"typeCast\":\"vector4\", \"value\":[0.5,0.5,0.5,1] },"
1633          "\"sensitive\":   { \"typeCast\":\"boolean\", \"value\":false },"
1634          "\"orientation\": { \"typeCast\":\"rotation\", \"value\":[10,10,10,10] },"
1635          "\"colorMode\":   { \"typeCast\":\"string\", \"value\":\"USE_OWN_MULTIPLY_PARENT_COLOR\" },"
1636          "\"clippingBox\": { \"typeCast\":\"rect\", \"value\":[10,10,10,10] },"
1637          "\"padding\":     { \"typeCast\":\"extents\", \"value\":[10,10,10,10] }"
1638       "}]"
1639     "}"
1640   );
1641
1642   Actor rootActor = Actor::New();
1643   application.GetScene().Add( rootActor );
1644
1645   Builder builder = Builder::New();
1646   builder.LoadFromString( json );
1647   builder.AddActors( rootActor );
1648
1649   application.SendNotification();
1650   application.Render();
1651
1652   Actor createdActor = rootActor.GetChildAt( 0 );
1653   DALI_TEST_EQUALS( createdActor.GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE ), Vector2(100.0f,15.0f), TEST_LOCATION );
1654   DALI_TEST_EQUALS( createdActor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3(100.0f,10.0f,1.0f), TEST_LOCATION );
1655   DALI_TEST_EQUALS( createdActor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Vector4(0.5f,0.5f,0.5f,1.0f), TEST_LOCATION );
1656   DALI_TEST_EQUALS( createdActor.GetProperty< bool >( Actor::Property::SENSITIVE ), false, TEST_LOCATION );
1657   DALI_TEST_EQUALS( createdActor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_OWN_MULTIPLY_PARENT_COLOR, TEST_LOCATION );
1658
1659   END_TEST;
1660 }
1661
1662 int UtcDaliBuilderBuilderControl(void)
1663 {
1664   ToolkitTestApplication application;
1665
1666   std::string json(
1667     "{"
1668        "\"stage\":"
1669        "[{"
1670          "\"type\": \"BuilderControl\","
1671          "\"integerProperty\": 10,"
1672          "\"matrix3Property\": [ 1,2,3,4,5,6,7,8,9 ],"
1673          "\"matrixProperty\":  [ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 ],"
1674          "\"noneProperty\": 10"
1675       "}]"
1676     "}"
1677   );
1678
1679   Actor rootActor = Actor::New();
1680   application.GetScene().Add( rootActor );
1681
1682   Builder builder = Builder::New();
1683   builder.LoadFromString( json );
1684   builder.AddActors( rootActor );
1685
1686   application.SendNotification();
1687   application.Render();
1688
1689   DALI_TEST_EQUALS( BuilderControlProperty::gSetPropertyCalledCount, 4, TEST_LOCATION );
1690
1691   END_TEST;
1692 }
1693
1694 int UtcDaliBuilderCustomControl(void)
1695 {
1696   ToolkitTestApplication application;
1697
1698   std::string json(
1699     "{"
1700        "\"stage\":"
1701        "[{"
1702          "\"type\": \"DummyControl\","
1703          "\"name\": \"I can haz custom Control\""
1704       "}]"
1705     "}"
1706   );
1707
1708   Actor rootActor = Actor::New();
1709   application.GetScene().Add( rootActor );
1710
1711   Builder builder = Builder::New();
1712   builder.LoadFromString( json );
1713   builder.AddActors( rootActor );
1714
1715   application.SendNotification();
1716   application.Render();
1717
1718   Actor customControl = rootActor.FindChildByName( "I can haz custom Control" );
1719
1720   // Test that we have the correct type of custom control
1721   DummyControl dummyControl = DummyControl::DownCast( customControl );
1722   DALI_TEST_CHECK( dummyControl );
1723   if( dummyControl )
1724   {
1725     DALI_TEST_CHECK( typeid(dummyControl.GetImplementation()) == typeid(DummyControlImpl) );
1726   }
1727
1728   END_TEST;
1729 }
1730
1731 int UtcDaliBuilderActionsWithParams(void)
1732 {
1733   ToolkitTestApplication application;
1734
1735   // JSON with a quit event when the actor is touched
1736   std::string json(
1737       "{\n"
1738       "\"stage\":\n"
1739       "[\n"
1740       "  { \n"
1741       "    \"type\": \"ImageView\",\n"
1742       "    \"name\": \"image\",\n"
1743       "    \"size\": [100,100,1],\n"
1744       "    \"signals\": [{\n"
1745       "      \"name\": \"touched\",\n"
1746       "      \"action\": \"show\",\n"
1747       "      \"parameters\": {\n"
1748       "        \"property1\" : 10,\n"
1749       "        \"property2\" : [1,2],\n"
1750       "        \"property3\" : [1,2,3],\n"
1751       "        \"property4\" : [1,2,3,4]\n"
1752       "      }\n"
1753       "    }]\n"
1754       "  }\n"
1755       "]\n"
1756       "}\n"
1757   );
1758
1759   Builder builder = Builder::New();
1760   builder.LoadFromString( json );
1761   builder.AddActors( application.GetScene().GetRootLayer() );
1762
1763   DALI_TEST_CHECK( true ); // For Coverage
1764
1765   END_TEST;
1766 }
1767
1768 int UtcDaliBuilderConfigurationP(void)
1769 {
1770   ToolkitTestApplication application;
1771
1772   // JSON with a quit event when the actor is touched
1773   std::string json(
1774       "{\n"
1775       "  \"config\":\n"
1776       "  {\n"
1777       "    \"alwaysShowFocus\":true\n"
1778       "  }\n"
1779       "}\n"
1780   );
1781
1782   Builder builder = Builder::New();
1783   builder.LoadFromString( json );
1784
1785   Property::Map map = builder.GetConfigurations();
1786
1787   Dali::Property::Value* pValue = map.Find( "alwaysShowFocus" );
1788
1789   DALI_TEST_CHECK( pValue );
1790
1791   bool value = pValue->Get<bool>();
1792
1793   DALI_TEST_CHECK( value );
1794
1795   END_TEST;
1796 }
1797
1798
1799 int UtcDaliBase64EncodingP(void)
1800 {
1801   std::vector<uint32_t> data = { 0, 1, 2, 3, 4, 5, std::numeric_limits<uint32_t>::min(), std::numeric_limits<uint32_t>::max()  };
1802
1803   Property::Value value;
1804   EncodeBase64PropertyData( value, data );
1805
1806   std::cout << "Max uint32_t:" << std::numeric_limits<uint32_t>::max() << std::endl;
1807   std::cout << "Input data:  ";
1808   std::ostream_iterator<uint32_t> out_it (std::cout,", ");
1809   std::copy ( data.begin(), data.end(), out_it );
1810   std::cout << std::endl;
1811
1812   std::string output;
1813   DALI_TEST_CHECK( value.Get( output ) );
1814   DALI_TEST_EQUALS( output, "AAAAAAEAAAACAAAAAwAAAAQAAAAFAAAAAAAAAP////8", TEST_LOCATION );
1815
1816   std::cout << "Output data:  " << output << std::endl;
1817
1818   END_TEST;
1819 }
1820
1821 int UtcDaliBase64EncodingN(void)
1822 {
1823   tet_infoline( "Test encoding an empty vector returns empty string" );
1824   std::vector<uint32_t> data;
1825
1826   Property::Value value;
1827   EncodeBase64PropertyData( value, data );
1828
1829   std::string output;
1830   DALI_TEST_CHECK( value.Get( output ) );
1831   DALI_TEST_EQUALS( output.empty(), true, TEST_LOCATION );
1832
1833   END_TEST;
1834 }
1835
1836 template <typename T>
1837 int b64l(std::vector<T>&data)
1838 {
1839   auto lengthInBytes = 4*data.size();
1840   return ceil( lengthInBytes * 1.33333f );
1841 }
1842
1843 int UtcDaliBase64EncodingP02(void)
1844 {
1845   tet_infoline( "Test encoding vectors of lengths m .. m+4 encode and decode back to the same length vectors" );
1846
1847   std::vector<uint32_t> testData;
1848   for(int i=0; i<8; ++i ) // 8 chosen to stay within single string output
1849   {
1850     testData.push_back(i);
1851   }
1852   Property::Value value;
1853   EncodeBase64PropertyData( value, testData );
1854
1855   std::string output;
1856   DALI_TEST_CHECK( value.Get( output ) );
1857   DALI_TEST_EQUALS( output.empty(), false, TEST_LOCATION);
1858   DALI_TEST_EQUALS( output.length(), b64l(testData), TEST_LOCATION );
1859
1860   std::vector<uint32_t> outData;
1861   DecodeBase64PropertyData( value, outData );
1862   DALI_TEST_EQUALS( testData.size(), outData.size(), TEST_LOCATION );
1863   DALI_TEST_EQUALS( std::equal( testData.begin(), testData.end(), outData.begin()), true, TEST_LOCATION );
1864
1865   // n+1
1866   testData.push_back( 12345 );
1867   EncodeBase64PropertyData( value, testData );
1868
1869   DALI_TEST_CHECK( value.Get( output ) );
1870   DALI_TEST_EQUALS( output.empty(), false, TEST_LOCATION);
1871   DALI_TEST_EQUALS( output.length(), b64l(testData), TEST_LOCATION );
1872
1873   outData.clear();
1874   DecodeBase64PropertyData( value, outData );
1875   DALI_TEST_EQUALS( testData.size(), outData.size(), TEST_LOCATION );
1876   DALI_TEST_EQUALS( std::equal( testData.begin(), testData.end(), outData.begin()), true, TEST_LOCATION );
1877
1878   // n+2
1879   testData.push_back( 67890 );
1880   EncodeBase64PropertyData( value, testData );
1881
1882   DALI_TEST_CHECK( value.Get( output ) );
1883   DALI_TEST_EQUALS( output.empty(), false, TEST_LOCATION);
1884   DALI_TEST_EQUALS( output.length(), b64l(testData), TEST_LOCATION );
1885
1886   outData.clear();
1887   DecodeBase64PropertyData( value, outData );
1888   DALI_TEST_EQUALS( testData.size(), outData.size(), TEST_LOCATION );
1889   DALI_TEST_EQUALS( std::equal( testData.begin(), testData.end(), outData.begin()), true, TEST_LOCATION );
1890
1891   // n+3
1892   testData.push_back( -1 );
1893   EncodeBase64PropertyData( value, testData );
1894
1895   DALI_TEST_CHECK( value.Get( output ) );
1896   DALI_TEST_EQUALS( output.empty(), false, TEST_LOCATION);
1897   DALI_TEST_EQUALS( output.length(), b64l(testData), TEST_LOCATION );
1898
1899   outData.clear();
1900   DecodeBase64PropertyData( value, outData );
1901   DALI_TEST_EQUALS( testData.size(), outData.size(), TEST_LOCATION );
1902   DALI_TEST_EQUALS( std::equal( testData.begin(), testData.end(), outData.begin()), true, TEST_LOCATION );
1903
1904
1905   END_TEST;
1906 }
1907
1908
1909 int UtcDaliBase64EncodingP03(void)
1910 {
1911   tet_infoline( "Test encoding a vector of length 12 has output within single string" );
1912
1913   std::vector<uint32_t> testData;
1914   for(int i=0; i<12; ++i )
1915   {
1916     testData.push_back(i);
1917   }
1918   Property::Value value;
1919   EncodeBase64PropertyData( value, testData );
1920
1921   std::string output;
1922   DALI_TEST_CHECK( value.Get( output ) );
1923   DALI_TEST_EQUALS( output.empty(), false, TEST_LOCATION);
1924   DALI_TEST_EQUALS( output.length(), b64l(testData), TEST_LOCATION );
1925
1926   std::vector<uint32_t> outData;
1927   DecodeBase64PropertyData( value, outData );
1928   DALI_TEST_EQUALS( testData.size(), outData.size(), TEST_LOCATION );
1929
1930   END_TEST;
1931 }
1932
1933
1934 int UtcDaliBase64EncodingP04(void)
1935 {
1936   tet_infoline( "Test encoding a vector of length 13 has output split over 2 strings" );
1937
1938   std::vector<uint32_t> testData;
1939   for(int i=0; i<13; ++i )
1940   {
1941     testData.push_back(i);
1942   }
1943   Property::Value value;
1944   EncodeBase64PropertyData( value, testData );
1945
1946   auto array = value.GetArray();
1947   DALI_TEST_CHECK( array );
1948
1949   DALI_TEST_EQUALS( array->Count(), 2, TEST_LOCATION );
1950
1951   std::vector<uint32_t> outData;
1952   DecodeBase64PropertyData( value, outData );
1953   DALI_TEST_EQUALS( testData.size(), outData.size(), TEST_LOCATION );
1954
1955   END_TEST;
1956 }
1957
1958
1959 int UtcDaliBase64EncodingP05(void)
1960 {
1961   tet_infoline( "Test encoding a vector of length 24 has output split over 2 strings" );
1962
1963   std::vector<uint32_t> testData;
1964   for(int i=0; i<24; ++i )
1965   {
1966     testData.push_back(i);
1967   }
1968   Property::Value value;
1969   EncodeBase64PropertyData( value, testData );
1970
1971   auto array = value.GetArray();
1972   DALI_TEST_CHECK( array );
1973
1974   DALI_TEST_EQUALS( array->Count(), 2, TEST_LOCATION );
1975
1976   std::vector<uint32_t> outData;
1977   DecodeBase64PropertyData( value, outData );
1978   DALI_TEST_EQUALS( testData.size(), outData.size(), TEST_LOCATION );
1979
1980   END_TEST;
1981 }
1982
1983
1984 int UtcDaliBase64EncodingP06(void)
1985 {
1986   tet_infoline( "Test encoding a vector of arbitrary length decodes OK." );
1987
1988   std::vector<uint32_t> testData;
1989   for(int i=0; i<97; ++i )
1990   {
1991     testData.push_back(i);
1992   }
1993   Property::Value value;
1994   EncodeBase64PropertyData( value, testData );
1995
1996   auto array = value.GetArray();
1997   DALI_TEST_CHECK( array );
1998
1999   std::vector<uint32_t> outData;
2000   DecodeBase64PropertyData( value, outData );
2001   DALI_TEST_EQUALS( testData.size(), outData.size(), TEST_LOCATION );
2002
2003   END_TEST;
2004 }
2005
2006
2007 int UtcDaliBase64DecodingN01(void)
2008 {
2009   tet_infoline( "Test decoding empty string results in empty data" );
2010
2011   Property::Value value("");
2012   std::vector<uint32_t> outputData;
2013   DecodeBase64PropertyData( value, outputData);
2014   DALI_TEST_EQUALS( outputData.size(), 0, TEST_LOCATION );
2015   END_TEST;
2016 }
2017
2018
2019 int UtcDaliBase64DecodingN02(void)
2020 {
2021   tet_infoline( "Test decoding array with non-string values results in empty data" );
2022
2023   Property::Array array;
2024   array.Resize(2);
2025   array[0] = "Stuff, things";
2026   array[1] = 1;
2027   Property::Value value(array);
2028
2029   std::vector<uint32_t> outputData;
2030   DecodeBase64PropertyData( value, outputData);
2031   DALI_TEST_EQUALS( outputData.size(), 0, TEST_LOCATION );
2032   END_TEST;
2033 }
2034
2035 int UtcDaliBase64DecodingP01(void)
2036 {
2037   tet_infoline( "Test decoding string of known data gives expected result");
2038
2039   std::string testInput("//////7+/v4DAgEA");
2040   std::vector<uint32_t> expectedResults = { 0xffffffff, 0xfefefefe, 0x00010203 };
2041
2042   std::vector<uint32_t> outputData;
2043   DecodeBase64PropertyData(Property::Value(testInput), outputData);
2044
2045   DALI_TEST_EQUALS( std::equal( expectedResults.begin(), expectedResults.end(), outputData.begin() ), true,
2046                     TEST_LOCATION );
2047
2048   END_TEST;
2049 }