Merge "Merge branch 'tizen' into devel/new_mesh" into devel/new_mesh
[platform/core/uifw/dali-toolkit.git] / automated-tests / src / dali-toolkit / utc-Dali-Alignment.cpp
1 /*
2  * Copyright (c) 2015 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 <stdlib.h>
20
21
22 // Need to override adaptor classes for toolkit test harness, so include
23 // test harness headers before dali headers.
24 #include <dali-toolkit-test-suite-utils.h>
25 #include <dali/integration-api/events/key-event-integ.h>
26 #include <dali/integration-api/events/touch-event-integ.h>
27 #include <dali-toolkit/dali-toolkit.h>
28
29 using namespace Dali;
30 using namespace Dali::Toolkit;
31
32 void utc_dali_toolkit_alignment_startup(void)
33 {
34   test_return_value = TET_UNDEF;
35 }
36
37 void utc_dali_toolkit_alignment_cleanup(void)
38 {
39   test_return_value = TET_PASS;
40 }
41
42
43 namespace
44 {
45 static bool gObjectCreatedCallBackCalled;
46
47 static void TestCallback(BaseHandle handle)
48 {
49   gObjectCreatedCallBackCalled = true;
50 }
51 } // namespace
52
53
54 int UtcDaliAlignmentConstructorNegative(void)
55 {
56   ToolkitTestApplication application;
57
58   Alignment alignment;
59
60   try
61   {
62     Alignment::Padding padding;
63     alignment.SetPadding(padding);
64     tet_result(TET_FAIL);
65   }
66   catch (DaliException& e)
67   {
68     DALI_TEST_ASSERT(e, "alignment", TEST_LOCATION );
69   }
70   END_TEST;
71 }
72
73 int UtcDaliAlignmentConstructorPositive(void)
74 {
75   ToolkitTestApplication application;
76
77   Alignment alignment = Alignment::New();
78
79   try
80   {
81     Alignment::Padding padding;
82     alignment.SetPadding(padding);
83     tet_result(TET_PASS);
84   }
85   catch (DaliException& exception)
86   {
87     tet_result(TET_FAIL);
88   }
89
90   Actor actor = alignment;
91   alignment = Alignment::DownCast( actor );
92
93   DALI_TEST_CHECK( alignment );
94   END_TEST;
95 }
96
97 int UtcDaliAlignmentConstructorRegister(void)
98 {
99   ToolkitTestApplication application;
100
101   //Te ensure the object is registered after creation
102   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
103   DALI_TEST_CHECK( registry );
104
105   gObjectCreatedCallBackCalled = false;
106   registry.ObjectCreatedSignal().Connect(&TestCallback);
107   {
108     Alignment alignment = Alignment::New();
109   }
110   DALI_TEST_CHECK( gObjectCreatedCallBackCalled );
111   END_TEST;
112 }
113
114 int UtcDaliAlignmentSetAlignmentTypePositiveOffStage(void)
115 {
116   ToolkitTestApplication application;
117
118   // Default, HorizontalCenter, VerticalCenter - Ensure they do not change!
119   {
120     Alignment alignment = Alignment::New();
121
122     // Check default values
123     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
124
125     Alignment::Type type(Alignment::Type(Alignment::HorizontalCenter | Alignment::VerticalCenter));
126     alignment.SetAlignmentType(type);
127     DALI_TEST_CHECK(alignment.GetAlignmentType() & type);
128   }
129
130   // HorizontalLeft, VerticalCenter
131   {
132     Alignment alignment = Alignment::New();
133
134     // Check default values
135     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
136
137     Alignment::Type type(Alignment::HorizontalLeft);
138     alignment.SetAlignmentType(type);
139     DALI_TEST_CHECK(alignment.GetAlignmentType() & type);
140   }
141
142   // HorizontalRight, VerticalCenter
143   {
144     Alignment alignment = Alignment::New();
145
146     // Check default values
147     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
148
149     Alignment::Type type(Alignment::HorizontalRight);
150     alignment.SetAlignmentType(type);
151     DALI_TEST_CHECK(alignment.GetAlignmentType() & type);
152   }
153
154   // HorizontalLeft, VerticalTop
155   {
156     Alignment alignment = Alignment::New();
157
158     // Check default values
159     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
160
161     Alignment::Type type(Alignment::Type(Alignment::HorizontalLeft | Alignment::VerticalTop));
162     alignment.SetAlignmentType(type);
163     DALI_TEST_CHECK(alignment.GetAlignmentType() & type);
164   }
165
166   // HorizontalCenter, VerticalTop
167   {
168     Alignment alignment = Alignment::New();
169
170     // Check default values
171     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
172
173     Alignment::Type type(Alignment::VerticalTop);
174     alignment.SetAlignmentType(type);
175     DALI_TEST_CHECK(alignment.GetAlignmentType() & type);
176   }
177
178   // HorizontalRight, VerticalTop
179   {
180     Alignment alignment = Alignment::New();
181
182     // Check default values
183     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
184
185     Alignment::Type type(Alignment::Type(Alignment::HorizontalRight | Alignment::VerticalTop));
186     alignment.SetAlignmentType(type);
187     DALI_TEST_CHECK(alignment.GetAlignmentType() & type);
188   }
189
190   // HorizontalLeft, VerticalBottom
191   {
192     Alignment alignment = Alignment::New();
193
194     // Check default values
195     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
196
197     Alignment::Type type(Alignment::Type(Alignment::HorizontalLeft | Alignment::VerticalBottom));
198     alignment.SetAlignmentType(type);
199     DALI_TEST_CHECK(alignment.GetAlignmentType() & type);
200   }
201
202   // HorizontalCenter, VerticalBottom
203   {
204     Alignment alignment = Alignment::New();
205
206     // Check default values
207     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
208
209     Alignment::Type type(Alignment::VerticalBottom);
210     alignment.SetAlignmentType(type);
211     DALI_TEST_CHECK(alignment.GetAlignmentType() & type);
212   }
213
214   // HorizontalRight, VerticalBottom
215   {
216     Alignment alignment = Alignment::New();
217
218     // Check default values
219     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
220
221     Alignment::Type type(Alignment::Type(Alignment::HorizontalRight | Alignment::VerticalBottom));
222     alignment.SetAlignmentType(type);
223     DALI_TEST_CHECK(alignment.GetAlignmentType() & type);
224   }
225   END_TEST;
226 }
227
228 int UtcDaliAlignmentSetAlignmentTypePositiveOnStage(void)
229 {
230   ToolkitTestApplication application;
231
232   // Default, HorizontalCenter, VerticalCenter - Ensure they do not change!
233   {
234     Alignment alignment = Alignment::New();
235     alignment.Add(RenderableActor::New());
236     Stage::GetCurrent().Add(alignment);
237     application.Render();
238     application.SendNotification();
239
240     // Check default values
241     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
242
243     Alignment::Type type(Alignment::Type(Alignment::HorizontalCenter | Alignment::VerticalCenter));
244     alignment.SetAlignmentType(type);
245     DALI_TEST_CHECK(alignment.GetAlignmentType() & type);
246
247     Stage::GetCurrent().Remove(alignment);
248     application.Render();
249     application.SendNotification();
250   }
251
252   // HorizontalLeft, VerticalCenter
253   {
254     Alignment alignment = Alignment::New();
255     alignment.Add(RenderableActor::New());
256     Stage::GetCurrent().Add(alignment);
257     application.Render();
258     application.SendNotification();
259
260     // Check default values
261     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
262
263     Alignment::Type type(Alignment::HorizontalLeft);
264     alignment.SetAlignmentType(type);
265     DALI_TEST_CHECK(alignment.GetAlignmentType() & type);
266
267     Stage::GetCurrent().Remove(alignment);
268     application.Render();
269     application.SendNotification();
270   }
271
272   // HorizontalRight, VerticalCenter
273   {
274     Alignment alignment = Alignment::New();
275     alignment.Add(RenderableActor::New());
276     Stage::GetCurrent().Add(alignment);
277     application.Render();
278     application.SendNotification();
279
280     // Check default values
281     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
282
283     Alignment::Type type(Alignment::HorizontalRight);
284     alignment.SetAlignmentType(type);
285     DALI_TEST_CHECK(alignment.GetAlignmentType() & type);
286
287     Stage::GetCurrent().Remove(alignment);
288     application.Render();
289     application.SendNotification();
290   }
291
292   // HorizontalLeft, VerticalTop
293   {
294     Alignment alignment = Alignment::New();
295     alignment.Add(RenderableActor::New());
296     Stage::GetCurrent().Add(alignment);
297     application.Render();
298     application.SendNotification();
299
300     // Check default values
301     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
302
303     Alignment::Type type(Alignment::Type(Alignment::HorizontalLeft | Alignment::VerticalTop));
304     alignment.SetAlignmentType(type);
305     DALI_TEST_CHECK(alignment.GetAlignmentType() & type);
306
307     Stage::GetCurrent().Remove(alignment);
308     application.Render();
309     application.SendNotification();
310   }
311
312   // HorizontalCenter, VerticalTop
313   {
314     Alignment alignment = Alignment::New();
315     alignment.Add(RenderableActor::New());
316     Stage::GetCurrent().Add(alignment);
317     application.Render();
318     application.SendNotification();
319
320     // Check default values
321     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
322
323     Alignment::Type type(Alignment::VerticalTop);
324     alignment.SetAlignmentType(type);
325     DALI_TEST_CHECK(alignment.GetAlignmentType() & type);
326
327     Stage::GetCurrent().Remove(alignment);
328     application.Render();
329     application.SendNotification();
330   }
331
332   // HorizontalRight, VerticalTop
333   {
334     Alignment alignment = Alignment::New();
335     alignment.Add(RenderableActor::New());
336     Stage::GetCurrent().Add(alignment);
337     application.Render();
338     application.SendNotification();
339
340     // Check default values
341     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
342
343     Alignment::Type type(Alignment::Type(Alignment::HorizontalRight | Alignment::VerticalTop));
344     alignment.SetAlignmentType(type);
345     DALI_TEST_CHECK(alignment.GetAlignmentType() & type);
346
347     Stage::GetCurrent().Remove(alignment);
348     application.Render();
349     application.SendNotification();
350   }
351
352   // HorizontalLeft, VerticalBottom
353   {
354     Alignment alignment = Alignment::New();
355     alignment.Add(RenderableActor::New());
356     Stage::GetCurrent().Add(alignment);
357     application.Render();
358     application.SendNotification();
359
360     // Check default values
361     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
362
363     Alignment::Type type(Alignment::Type(Alignment::HorizontalLeft | Alignment::VerticalBottom));
364     alignment.SetAlignmentType(type);
365     DALI_TEST_CHECK(alignment.GetAlignmentType() & type);
366
367     Stage::GetCurrent().Remove(alignment);
368     application.Render();
369     application.SendNotification();
370   }
371
372   // HorizontalCenter, VerticalBottom
373   {
374     Alignment alignment = Alignment::New();
375     alignment.Add(RenderableActor::New());
376     Stage::GetCurrent().Add(alignment);
377     application.Render();
378     application.SendNotification();
379
380     // Check default values
381     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
382
383     Alignment::Type type(Alignment::VerticalBottom);
384     alignment.SetAlignmentType(type);
385     DALI_TEST_CHECK(alignment.GetAlignmentType() & type);
386
387     Stage::GetCurrent().Remove(alignment);
388     application.Render();
389     application.SendNotification();
390   }
391
392   // HorizontalRight, VerticalBottom
393   {
394     Alignment alignment = Alignment::New();
395     alignment.Add(RenderableActor::New());
396     Stage::GetCurrent().Add(alignment);
397     application.Render();
398     application.SendNotification();
399
400     // Check default values
401     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
402
403     Alignment::Type type(Alignment::Type(Alignment::HorizontalRight | Alignment::VerticalBottom));
404     alignment.SetAlignmentType(type);
405     DALI_TEST_CHECK(alignment.GetAlignmentType() & type);
406
407     Stage::GetCurrent().Remove(alignment);
408     application.Render();
409     application.SendNotification();
410   }
411   END_TEST;
412 }
413
414 int UtcDaliAlignmentSetAlignmentTypeNegative(void)
415 {
416   ToolkitTestApplication application;
417
418   // Setting HorizontalLeft, HorizontalCenter
419   {
420     Alignment alignment = Alignment::New();
421     Alignment::Type type(Alignment::Type(Alignment::HorizontalLeft | Alignment::HorizontalCenter));
422     alignment.SetAlignmentType(type);
423     // center will prevail in conflict
424     DALI_TEST_CHECK( Alignment::HorizontalCenter & alignment.GetAlignmentType() );
425     DALI_TEST_CHECK( !(Alignment::HorizontalLeft & alignment.GetAlignmentType()) );
426   }
427
428   // Setting HorizontalCenter, HorizontalRight
429   {
430     Alignment alignment = Alignment::New();
431     Alignment::Type type(Alignment::Type(Alignment::HorizontalCenter | Alignment::HorizontalRight));
432
433     alignment.SetAlignmentType(type);
434     // center will prevail in conflict
435     DALI_TEST_CHECK( Alignment::HorizontalCenter & alignment.GetAlignmentType() );
436     DALI_TEST_CHECK( !(Alignment::HorizontalRight & alignment.GetAlignmentType()) );
437   }
438
439   // Setting VerticalTop, VerticalCenter
440   {
441     Alignment alignment = Alignment::New();
442     Alignment::Type type(Alignment::Type(Alignment::VerticalTop | Alignment::VerticalCenter));
443     alignment.SetAlignmentType(type);
444     // center will prevail in conflict
445     DALI_TEST_CHECK( Alignment::VerticalCenter & alignment.GetAlignmentType() );
446     DALI_TEST_CHECK( !(Alignment::VerticalTop & alignment.GetAlignmentType()) );
447   }
448
449   // Setting VerticalCenter, VerticalBottom
450   {
451     Alignment alignment = Alignment::New();
452     Alignment::Type type(Alignment::Type(Alignment::VerticalTop | Alignment::VerticalBottom));
453     alignment.SetAlignmentType(type);
454     // top will prevail in conflict
455     DALI_TEST_CHECK( Alignment::VerticalTop & alignment.GetAlignmentType() );
456     DALI_TEST_CHECK( !(Alignment::VerticalBottom & alignment.GetAlignmentType()) );
457   }
458   END_TEST;
459 }
460
461 int UtcDaliAlignmentGetAlignmentType(void)
462 {
463   ToolkitTestApplication application;
464
465   // Default, HorizonalCenter, VerticalCenter
466   {
467     Alignment alignment = Alignment::New();
468     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
469     alignment.Add(RenderableActor::New());
470     Stage::GetCurrent().Add(alignment);
471     application.Render();
472     application.SendNotification();
473     Stage::GetCurrent().Remove(alignment);
474     application.Render();
475     application.SendNotification();
476   }
477
478   // HorizontalLeft, VerticalCenter
479   {
480     Alignment alignment = Alignment::New(Alignment::HorizontalLeft);
481     DALI_TEST_EQUALS(Alignment::HorizontalLeft | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
482     alignment.Add(RenderableActor::New());
483     Stage::GetCurrent().Add(alignment);
484     application.Render();
485     application.SendNotification();
486     Stage::GetCurrent().Remove(alignment);
487     application.Render();
488     application.SendNotification();
489   }
490
491   // HorizontalRight, VerticalCenter
492   {
493     Alignment alignment = Alignment::New(Alignment::HorizontalRight);
494     DALI_TEST_EQUALS(Alignment::HorizontalRight | Alignment::VerticalCenter, alignment.GetAlignmentType(), TEST_LOCATION);
495     alignment.Add(RenderableActor::New());
496     Stage::GetCurrent().Add(alignment);
497     application.Render();
498     application.SendNotification();
499     Stage::GetCurrent().Remove(alignment);
500     application.Render();
501     application.SendNotification();
502   }
503
504   // HorizontalLeft, VerticalTop
505   {
506     Alignment alignment = Alignment::New(Alignment::HorizontalLeft, Alignment::VerticalTop);
507     DALI_TEST_EQUALS(Alignment::HorizontalLeft | Alignment::VerticalTop, alignment.GetAlignmentType(), TEST_LOCATION);
508     alignment.Add(RenderableActor::New());
509     Stage::GetCurrent().Add(alignment);
510     application.Render();
511     application.SendNotification();
512     Stage::GetCurrent().Remove(alignment);
513     application.Render();
514     application.SendNotification();
515   }
516
517   // HorizontalCenter, VerticalTop
518   {
519     Alignment alignment = Alignment::New(Alignment::HorizontalCenter, Alignment::VerticalTop);
520     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalTop, alignment.GetAlignmentType(), TEST_LOCATION);
521     alignment.Add(RenderableActor::New());
522     Stage::GetCurrent().Add(alignment);
523     application.Render();
524     application.SendNotification();
525     Stage::GetCurrent().Remove(alignment);
526     application.Render();
527     application.SendNotification();
528   }
529
530   // HorizontalRight, VerticalTop
531   {
532     Alignment alignment = Alignment::New(Alignment::HorizontalRight, Alignment::VerticalTop);
533     DALI_TEST_EQUALS(Alignment::HorizontalRight | Alignment::VerticalTop, alignment.GetAlignmentType(), TEST_LOCATION);
534     alignment.Add(RenderableActor::New());
535     Stage::GetCurrent().Add(alignment);
536     application.Render();
537     application.SendNotification();
538     Stage::GetCurrent().Remove(alignment);
539     application.Render();
540     application.SendNotification();
541   }
542
543   // HorizontalLeft, VerticalBottom
544   {
545     Alignment alignment = Alignment::New(Alignment::HorizontalLeft, Alignment::VerticalBottom);
546     DALI_TEST_EQUALS(Alignment::HorizontalLeft | Alignment::VerticalBottom, alignment.GetAlignmentType(), TEST_LOCATION);
547     alignment.Add(RenderableActor::New());
548     Stage::GetCurrent().Add(alignment);
549     application.Render();
550     application.SendNotification();
551     Stage::GetCurrent().Remove(alignment);
552     application.Render();
553     application.SendNotification();
554   }
555
556   // HorizontalCenter, VerticalBottom
557   {
558     Alignment alignment = Alignment::New(Alignment::HorizontalCenter, Alignment::VerticalBottom);
559     DALI_TEST_EQUALS(Alignment::HorizontalCenter | Alignment::VerticalBottom, alignment.GetAlignmentType(), TEST_LOCATION);
560     alignment.Add(RenderableActor::New());
561     Stage::GetCurrent().Add(alignment);
562     application.Render();
563     application.SendNotification();
564     Stage::GetCurrent().Remove(alignment);
565     application.Render();
566     application.SendNotification();
567   }
568
569   // HorizontalRight, VerticalBottom
570   {
571     Alignment alignment = Alignment::New(Alignment::HorizontalRight, Alignment::VerticalBottom);
572     DALI_TEST_EQUALS(Alignment::HorizontalRight | Alignment::VerticalBottom, alignment.GetAlignmentType(), TEST_LOCATION);
573     alignment.Add(RenderableActor::New());
574     Stage::GetCurrent().Add(alignment);
575     application.Render();
576     application.SendNotification();
577     Stage::GetCurrent().Remove(alignment);
578     application.Render();
579     application.SendNotification();
580   }
581   END_TEST;
582 }
583
584 int UtcDaliAlignmentSetScaling(void)
585 {
586   ToolkitTestApplication application;
587
588   // ScaleToFill
589   {
590     Alignment alignment = Alignment::New();
591     alignment.Add(RenderableActor::New());
592     Stage::GetCurrent().Add(alignment);
593     application.Render();
594     application.SendNotification();
595
596     DALI_TEST_EQUALS(Alignment::ScaleNone, alignment.GetScaling(), TEST_LOCATION);
597     alignment.SetScaling(Alignment::ScaleToFill);
598     DALI_TEST_EQUALS(Alignment::ScaleToFill, alignment.GetScaling(), TEST_LOCATION);
599     application.Render();
600     application.SendNotification();
601
602     // For complete line coverage
603     alignment.SetAlignmentType(Alignment::HorizontalLeft);
604     application.Render();
605     application.SendNotification();
606     alignment.SetAlignmentType(Alignment::HorizontalRight);
607     application.Render();
608     application.SendNotification();
609     alignment.SetAlignmentType(Alignment::VerticalTop);
610     application.Render();
611     application.SendNotification();
612     alignment.SetAlignmentType(Alignment::VerticalBottom);
613     application.Render();
614     application.SendNotification();
615
616     Stage::GetCurrent().Remove(alignment);
617     application.Render();
618     application.SendNotification();
619   }
620
621   // ScaleToFitKeepAspect
622   {
623     Alignment alignment = Alignment::New();
624     alignment.Add(RenderableActor::New());
625     Stage::GetCurrent().Add(alignment);
626     application.Render();
627     application.SendNotification();
628
629     DALI_TEST_EQUALS(Alignment::ScaleNone, alignment.GetScaling(), TEST_LOCATION);
630     alignment.SetScaling(Alignment::ScaleToFitKeepAspect);
631     DALI_TEST_EQUALS(Alignment::ScaleToFitKeepAspect, alignment.GetScaling(), TEST_LOCATION);
632     application.Render();
633     application.SendNotification();
634
635     // For complete line coverage
636     alignment.SetAlignmentType(Alignment::HorizontalLeft);
637     application.Render();
638     application.SendNotification();
639     alignment.SetAlignmentType(Alignment::HorizontalRight);
640     application.Render();
641     application.SendNotification();
642     alignment.SetAlignmentType(Alignment::VerticalTop);
643     application.Render();
644     application.SendNotification();
645     alignment.SetAlignmentType(Alignment::VerticalBottom);
646     application.Render();
647     application.SendNotification();
648
649     Stage::GetCurrent().Remove(alignment);
650     application.Render();
651     application.SendNotification();
652   }
653
654   // ScaleToFillKeepAspect
655   {
656     Alignment alignment = Alignment::New();
657     alignment.Add(RenderableActor::New());
658     Stage::GetCurrent().Add(alignment);
659     application.Render();
660     application.SendNotification();
661
662     DALI_TEST_EQUALS(Alignment::ScaleNone, alignment.GetScaling(), TEST_LOCATION);
663     alignment.SetScaling(Alignment::ScaleToFillKeepAspect);
664     DALI_TEST_EQUALS(Alignment::ScaleToFillKeepAspect, alignment.GetScaling(), TEST_LOCATION);
665     application.Render();
666     application.SendNotification();
667
668     // For complete line coverage
669     alignment.SetAlignmentType(Alignment::HorizontalLeft);
670     application.Render();
671     application.SendNotification();
672     alignment.SetAlignmentType(Alignment::HorizontalRight);
673     application.Render();
674     application.SendNotification();
675     alignment.SetAlignmentType(Alignment::VerticalTop);
676     application.Render();
677     application.SendNotification();
678     alignment.SetAlignmentType(Alignment::VerticalBottom);
679     application.Render();
680     application.SendNotification();
681
682     Stage::GetCurrent().Remove(alignment);
683     application.Render();
684     application.SendNotification();
685   }
686
687   // ShrinkToFit
688   {
689     Alignment alignment = Alignment::New();
690     alignment.Add(RenderableActor::New());
691     Stage::GetCurrent().Add(alignment);
692     application.Render();
693     application.SendNotification();
694
695     DALI_TEST_EQUALS(Alignment::ScaleNone, alignment.GetScaling(), TEST_LOCATION);
696     alignment.SetScaling(Alignment::ShrinkToFit);
697     DALI_TEST_EQUALS(Alignment::ShrinkToFit, alignment.GetScaling(), TEST_LOCATION);
698     application.Render();
699     application.SendNotification();
700
701     // For complete line coverage
702     alignment.SetAlignmentType(Alignment::HorizontalLeft);
703     application.Render();
704     application.SendNotification();
705     alignment.SetAlignmentType(Alignment::HorizontalRight);
706     application.Render();
707     application.SendNotification();
708     alignment.SetAlignmentType(Alignment::VerticalTop);
709     application.Render();
710     application.SendNotification();
711     alignment.SetAlignmentType(Alignment::VerticalBottom);
712     application.Render();
713     application.SendNotification();
714
715     Stage::GetCurrent().Remove(alignment);
716     application.Render();
717     application.SendNotification();
718   }
719
720   // ShrinkToFitKeepAspect
721   {
722     Alignment alignment = Alignment::New();
723     alignment.Add(RenderableActor::New());
724     Stage::GetCurrent().Add(alignment);
725     application.Render();
726     application.SendNotification();
727
728     DALI_TEST_EQUALS(Alignment::ScaleNone, alignment.GetScaling(), TEST_LOCATION);
729     alignment.SetScaling(Alignment::ShrinkToFitKeepAspect);
730     DALI_TEST_EQUALS(Alignment::ShrinkToFitKeepAspect, alignment.GetScaling(), TEST_LOCATION);
731     application.Render();
732     application.SendNotification();
733
734     // For complete line coverage
735     alignment.SetAlignmentType(Alignment::HorizontalLeft);
736     application.Render();
737     application.SendNotification();
738     alignment.SetAlignmentType(Alignment::HorizontalRight);
739     application.Render();
740     application.SendNotification();
741     alignment.SetAlignmentType(Alignment::VerticalTop);
742     application.Render();
743     application.SendNotification();
744     alignment.SetAlignmentType(Alignment::VerticalBottom);
745     application.Render();
746     application.SendNotification();
747
748     Stage::GetCurrent().Remove(alignment);
749     application.Render();
750     application.SendNotification();
751   }
752   END_TEST;
753 }
754
755 int UtcDaliAlignmentGetScaling(void)
756 {
757   ToolkitTestApplication application;
758
759   // ScaleToFill
760   {
761     Alignment alignment = Alignment::New();
762     DALI_TEST_CHECK(alignment.GetScaling() == Alignment::ScaleNone);
763
764     alignment.SetScaling(Alignment::ScaleToFill);
765     DALI_TEST_CHECK(alignment.GetScaling() == Alignment::ScaleToFill);
766   }
767
768   // ScaleToFitKeepAspect
769   {
770     Alignment alignment = Alignment::New();
771     DALI_TEST_CHECK(alignment.GetScaling() == Alignment::ScaleNone);
772
773     alignment.SetScaling(Alignment::ScaleToFitKeepAspect);
774     DALI_TEST_CHECK(alignment.GetScaling() == Alignment::ScaleToFitKeepAspect);
775   }
776
777   // ScaleToFillKeepAspect
778   {
779     Alignment alignment = Alignment::New();
780     DALI_TEST_CHECK(alignment.GetScaling() == Alignment::ScaleNone);
781
782     alignment.SetScaling(Alignment::ScaleToFillKeepAspect);
783     DALI_TEST_CHECK(alignment.GetScaling() == Alignment::ScaleToFillKeepAspect);
784   }
785
786   // ShrinkToFit
787   {
788     Alignment alignment = Alignment::New();
789     DALI_TEST_CHECK(alignment.GetScaling() == Alignment::ScaleNone);
790
791     alignment.SetScaling(Alignment::ShrinkToFit);
792     DALI_TEST_CHECK(alignment.GetScaling() == Alignment::ShrinkToFit);
793   }
794
795   // ShrinkToFitKeepAspect
796   {
797     Alignment alignment = Alignment::New();
798     DALI_TEST_CHECK(alignment.GetScaling() == Alignment::ScaleNone);
799
800     alignment.SetScaling(Alignment::ShrinkToFitKeepAspect);
801     DALI_TEST_CHECK(alignment.GetScaling() == Alignment::ShrinkToFitKeepAspect);
802   }
803
804   END_TEST;
805 }
806
807 int UtcDaliAlignmentSetPaddingPositive(void)
808 {
809   ToolkitTestApplication application;
810
811   Alignment alignment = Alignment::New();
812
813   Alignment::Padding padding(1.0f, 1.5f, 2.f, 0.5f);
814   DALI_TEST_CHECK( fabs( padding.left - alignment.GetPadding().left ) > GetRangedEpsilon( padding.left, alignment.GetPadding().left ) );
815   DALI_TEST_CHECK( fabs( padding.right - alignment.GetPadding().right ) > GetRangedEpsilon( padding.right, alignment.GetPadding().right ) );
816   DALI_TEST_CHECK( fabs( padding.top - alignment.GetPadding().top ) > GetRangedEpsilon( padding.top, alignment.GetPadding().top ) );
817   DALI_TEST_CHECK( fabs( padding.bottom - alignment.GetPadding().bottom ) > GetRangedEpsilon( padding.bottom, alignment.GetPadding().bottom ) );
818
819   alignment.SetPadding(padding);
820   DALI_TEST_CHECK( fabs( padding.left - alignment.GetPadding().left ) < GetRangedEpsilon( padding.left, alignment.GetPadding().left ) );
821   DALI_TEST_CHECK( fabs( padding.right - alignment.GetPadding().right ) < GetRangedEpsilon( padding.right, alignment.GetPadding().right ) );
822   DALI_TEST_CHECK( fabs( padding.top - alignment.GetPadding().top ) < GetRangedEpsilon( padding.top, alignment.GetPadding().top ) );
823   DALI_TEST_CHECK( fabs( padding.bottom - alignment.GetPadding().bottom ) < GetRangedEpsilon( padding.bottom, alignment.GetPadding().bottom ) );
824   END_TEST;
825 }
826
827 int UtcDaliAlignmentSetPaddingNegative(void)
828 {
829   ToolkitTestApplication application;
830
831   Alignment alignment = Alignment::New();
832
833   try
834   {
835     Alignment::Padding padding(-1.0f, 1.5f, 2.f, 0.f);
836     alignment.SetPadding(padding);
837     tet_result(TET_FAIL);
838   }
839   catch (DaliException& e)
840   {
841     DALI_TEST_ASSERT(e, "( padding.left >= 0.f ) && ( padding.top >= 0.f ) && ( padding.right >= 0.f ) && ( padding.bottom >= 0.f )", TEST_LOCATION );
842   }
843
844   try
845   {
846     Alignment::Padding padding(1.0f, 1.5f, -2.f, 0.f);
847     alignment.SetPadding(padding);
848     tet_result(TET_FAIL);
849   }
850   catch (DaliException& e)
851   {
852     DALI_TEST_ASSERT(e, "( padding.left >= 0.f ) && ( padding.top >= 0.f ) && ( padding.right >= 0.f ) && ( padding.bottom >= 0.f )", TEST_LOCATION );
853   }
854
855   try
856   {
857     Alignment::Padding padding(1.0f, 1.5f, 2.f, -1.f);
858     alignment.SetPadding(padding);
859     tet_result(TET_FAIL);
860   }
861   catch (DaliException& e)
862   {
863     DALI_TEST_ASSERT(e, "( padding.left >= 0.f ) && ( padding.top >= 0.f ) && ( padding.right >= 0.f ) && ( padding.bottom >= 0.f )", TEST_LOCATION );
864   }
865
866   try
867   {
868     Alignment::Padding padding(1.0f, -1.5f, 2.f, 0.f);
869     alignment.SetPadding(padding);
870     tet_result(TET_FAIL);
871   }
872   catch (DaliException& e)
873   {
874     DALI_TEST_ASSERT(e, "( padding.left >= 0.f ) && ( padding.top >= 0.f ) && ( padding.right >= 0.f ) && ( padding.bottom >= 0.f )", TEST_LOCATION );
875   }
876   END_TEST;
877 }
878
879 int UtcDaliAlignmentGetPadding(void)
880 {
881   ToolkitTestApplication application;
882
883   Alignment alignment = Alignment::New();
884   DALI_TEST_CHECK( fabs( alignment.GetPadding().left ) < GetRangedEpsilon( 0.f, alignment.GetPadding().left ) );
885   DALI_TEST_CHECK( fabs( alignment.GetPadding().right ) < GetRangedEpsilon( 0.f, alignment.GetPadding().right ) );
886   DALI_TEST_CHECK( fabs( alignment.GetPadding().top ) < GetRangedEpsilon( 0.f, alignment.GetPadding().top ) );
887   DALI_TEST_CHECK( fabs( alignment.GetPadding().bottom ) < GetRangedEpsilon( 0.f, alignment.GetPadding().bottom ) );
888
889   Alignment::Padding padding(1.0f, 1.5f, 2.f, 0.f);
890   alignment.SetPadding(padding);
891   DALI_TEST_CHECK( fabs( padding.left - alignment.GetPadding().left ) < GetRangedEpsilon( padding.left, alignment.GetPadding().left ) );
892   DALI_TEST_CHECK( fabs( padding.right - alignment.GetPadding().right ) < GetRangedEpsilon( padding.right, alignment.GetPadding().right ) );
893   DALI_TEST_CHECK( fabs( padding.top - alignment.GetPadding().top ) < GetRangedEpsilon( padding.top, alignment.GetPadding().top ) );
894   DALI_TEST_CHECK( fabs( padding.bottom - alignment.GetPadding().bottom ) < GetRangedEpsilon( padding.bottom, alignment.GetPadding().bottom ) );
895   END_TEST;
896 }
897
898 int UtcDaliAlignmentChildAddAndRemove(void)
899 {
900   ToolkitTestApplication application;
901
902   Alignment alignment = Alignment::New();
903   Stage::GetCurrent().Add(alignment);
904
905   application.Render();
906   application.SendNotification();
907
908   Actor actor = RenderableActor::New();
909   alignment.Add(actor);
910
911   DALI_TEST_EQUALS(alignment.GetChildCount(), 1u, TEST_LOCATION);
912
913   application.Render();
914   application.SendNotification();
915
916   alignment.Remove(actor);
917
918   DALI_TEST_EQUALS(alignment.GetChildCount(), 0u, TEST_LOCATION);
919
920   application.Render();
921   application.SendNotification();
922
923   Stage::GetCurrent().Remove(alignment);
924   END_TEST;
925 }
926
927 int UtcDaliAlignmentSizeSetP(void)
928 {
929   ToolkitTestApplication application;
930
931   Alignment alignment = Alignment::New();
932   Stage::GetCurrent().Add(alignment);
933
934   application.Render();
935   application.SendNotification();
936
937   Vector2 size( 100.0f, 200.0f );
938   alignment.SetSize(size);
939
940   application.Render();
941   application.SendNotification();
942   application.Render();
943   application.SendNotification();
944
945   DALI_TEST_EQUALS(size, alignment.GetTargetSize().GetVectorXY(), TEST_LOCATION);
946
947   Stage::GetCurrent().Remove(alignment);
948   END_TEST;
949 }
950
951 ///////////////////////////////////////////////////////////////////////////////
952 static bool TouchEventCallback(Actor actor, const TouchEvent& event)
953 {
954   return false;
955 }
956
957 ///////////////////////////////////////////////////////////////////////////////
958
959 int UtcDaliAlignmentOnTouchEvent(void)
960 {
961   ToolkitTestApplication application;
962
963   Alignment alignment = Alignment::New();
964   alignment.SetSize(100.0f, 100.0f);
965   alignment.SetAnchorPoint(AnchorPoint::TOP_LEFT);
966   Stage::GetCurrent().Add(alignment);
967
968   alignment.TouchedSignal().Connect(&TouchEventCallback);
969
970   application.Render();
971   application.SendNotification();
972   application.Render();
973   application.SendNotification();
974
975   Integration::TouchEvent touchEvent(1);
976   TouchPoint point(1, TouchPoint::Down, 20.0f, 20.0f);
977   touchEvent.AddPoint(point);
978   application.ProcessEvent(touchEvent);
979
980   tet_result(TET_PASS); // For line coverage, as long as there are no exceptions, we assume passed.
981   END_TEST;
982 }
983
984 int UtcDaliAlignmentOnKeyEvent(void)
985 {
986   ToolkitTestApplication application;
987
988   Alignment alignment = Alignment::New();
989   Stage::GetCurrent().Add(alignment);
990
991   alignment.SetKeyInputFocus();
992
993   application.Render();
994   application.SendNotification();
995   application.Render();
996   application.SendNotification();
997
998   Integration::KeyEvent keyEvent;
999   application.ProcessEvent(keyEvent);
1000
1001   tet_result(TET_PASS); // For line coverage, as long as there are no exceptions, we assume passed.
1002   END_TEST;
1003 }
1004
1005 int UtcDaliAlignmentOnSizeAnimation(void)
1006 {
1007   ToolkitTestApplication application;
1008
1009   Alignment alignment = Alignment::New();
1010   Stage::GetCurrent().Add(alignment);
1011
1012   Animation animation = Animation::New(100.0f);
1013   animation.AnimateTo( Property( alignment, Actor::Property::SIZE ), Vector3( 100.0f, 150.0f, 200.0f ) );
1014   animation.Play();
1015
1016   application.Render();
1017   application.SendNotification();
1018   application.Render();
1019   application.SendNotification();
1020
1021   tet_result(TET_PASS); // For line coverage, as long as there are no exceptions, we assume passed.
1022   END_TEST;
1023 }
1024
1025 int UtcDaliAlignmentCopyAndAssignment(void)
1026 {
1027   ToolkitTestApplication application;
1028
1029   Alignment alignment = Alignment::New();
1030   Alignment emptyAlignment;
1031
1032   Alignment::Padding padding(100.0f, 150.0f, 200.f, 0.f);
1033   alignment.SetPadding(padding);
1034
1035   Alignment alignmentCopy(alignment);
1036   DALI_TEST_CHECK( fabs( padding.left - alignmentCopy.GetPadding().left ) < GetRangedEpsilon( padding.left, alignmentCopy.GetPadding().left ) );
1037   DALI_TEST_CHECK( fabs( padding.right - alignmentCopy.GetPadding().right ) < GetRangedEpsilon( padding.right, alignmentCopy.GetPadding().right ) );
1038   DALI_TEST_CHECK( fabs( padding.top - alignmentCopy.GetPadding().top ) < GetRangedEpsilon( padding.top, alignmentCopy.GetPadding().top ) );
1039   DALI_TEST_CHECK( fabs( padding.bottom - alignmentCopy.GetPadding().bottom ) < GetRangedEpsilon( padding.bottom, alignmentCopy.GetPadding().bottom ) );
1040
1041   Alignment alignmentEmptyCopy(emptyAlignment);
1042   DALI_TEST_CHECK(emptyAlignment == alignmentEmptyCopy);
1043
1044   Alignment alignmentEquals;
1045   alignmentEquals = alignment;
1046   DALI_TEST_CHECK( fabs( padding.left - alignmentEquals.GetPadding().left ) < GetRangedEpsilon( padding.left, alignmentEquals.GetPadding().left ) );
1047   DALI_TEST_CHECK( fabs( padding.right - alignmentEquals.GetPadding().right ) < GetRangedEpsilon( padding.right, alignmentEquals.GetPadding().right ) );
1048   DALI_TEST_CHECK( fabs( padding.top - alignmentEquals.GetPadding().top ) < GetRangedEpsilon( padding.top, alignmentEquals.GetPadding().top ) );
1049   DALI_TEST_CHECK( fabs( padding.bottom - alignmentEquals.GetPadding().bottom ) < GetRangedEpsilon( padding.bottom, alignmentEquals.GetPadding().bottom ) );
1050
1051   Alignment alignmentEmptyEquals;
1052   alignmentEmptyEquals = emptyAlignment;
1053   DALI_TEST_CHECK(emptyAlignment == alignmentEmptyEquals);
1054
1055   // Self assignment
1056   alignment = alignment;
1057   DALI_TEST_CHECK(alignment == alignmentCopy);
1058   END_TEST;
1059 }