automated-tests/src/dali/utc-Dali-Actor.cpp

   1 /*
   2  * Copyright (c) 2019 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 "assert.h"
  19 #include <dali/public-api/dali-core.h>
  20 #include <string>
  21 #include <cfloat>   // For FLT_MAX
  22 #include <dali/devel-api/actors/actor-devel.h>
  23 #include <dali/integration-api/events/touch-event-integ.h>
  24 #include <dali/integration-api/events/hover-event-integ.h>
  25 #include <dali-test-suite-utils.h>
  26 #include <mesh-builder.h>
  27
  28 //& set: DaliActor
  29
  30 using std::string;
  31 using namespace Dali;
  32
  33
  34 void utc_dali_actor_startup(void)
  35 {
  36   test_return_value = TET_UNDEF;
  37 }
  38
  39 void utc_dali_actor_cleanup(void)
  40 {
  41   test_return_value = TET_PASS;
  42 }
  43
  44 namespace
  45 {
  46 bool gTouchCallBackCalled=false;
  47 bool gTouchCallBackCalled2=false;
  48 bool gTouchCallBackCalled3=false;
  49
  50 bool gHoverCallBackCalled=false;
  51
  52 static bool gTestConstraintCalled;
  53
  54 LayoutDirection::Type gLayoutDirectionType;
  55
  56 struct TestConstraint
  57 {
  58   void operator()( Vector4& color, const PropertyInputContainer& /* inputs */ )
  59   {
  60     gTestConstraintCalled = true;
  61   }
  62 };
  63
  64 /**
  65  * TestConstraint reference.
  66  * When constraint is called, the resultRef is updated
  67  * with the value supplied.
  68  */
  69 template<typename T>
  70 struct TestConstraintRef
  71 {
  72   TestConstraintRef(unsigned int& resultRef, unsigned int value)
  73   : mResultRef(resultRef),
  74     mValue(value)
  75   {
  76   }
  77
  78   void operator()( T& current, const PropertyInputContainer& /* inputs */ )
  79   {
  80     mResultRef = mValue;
  81   }
  82
  83   unsigned int& mResultRef;
  84   unsigned int mValue;
  85 };
  86
  87 static bool TestCallback(Actor actor, const TouchEvent& event)
  88 {
  89   gTouchCallBackCalled = true;
  90   return false;
  91   END_TEST;
  92 }
  93
  94 static bool TestTouchCallback(Actor actor, const TouchData& touchData )
  95 {
  96   gTouchCallBackCalled = true;
  97   return true;
  98   END_TEST;
  99 }
 100
 101 static bool TestTouchCallback2(Actor actor, const TouchData& touchData )
 102 {
 103   gTouchCallBackCalled2 = true;
 104   return true;
 105   END_TEST;
 106 }
 107
 108 static bool TestTouchCallback3(Actor actor, const TouchData& touchData )
 109 {
 110   gTouchCallBackCalled3 = true;
 111   return true;
 112   END_TEST;
 113 }
 114
 115 static void ResetTouchCallbacks()
 116 {
 117   gTouchCallBackCalled = false;
 118   gTouchCallBackCalled2 = false;
 119   gTouchCallBackCalled3 = false;
 120 }
 121
 122 static bool TestCallback3(Actor actor, const HoverEvent& event)
 123 {
 124   gHoverCallBackCalled = true;
 125   return false;
 126   END_TEST;
 127 }
 128
 129 // validation stuff for onstage & offstage signals
 130 static std::vector< std::string > gActorNamesOnOffStage;
 131 static int gOnStageCallBackCalled;
 132 void OnStageCallback( Actor actor )
 133 {
 134   ++gOnStageCallBackCalled;
 135   gActorNamesOnOffStage.push_back( actor.GetName() );
 136   DALI_TEST_CHECK( actor.OnStage() == true );
 137 }
 138 static int gOffStageCallBackCalled;
 139 void OffStageCallback( Actor actor )
 140 {
 141   ++gOffStageCallBackCalled;
 142   gActorNamesOnOffStage.push_back( actor.GetName() );
 143   DALI_TEST_CHECK( actor.OnStage() == false );
 144 }
 145
 146 struct PositionComponentConstraint
 147 {
 148   PositionComponentConstraint(){}
 149
 150   void operator()( Vector3& pos, const PropertyInputContainer& inputs )
 151   {
 152     const Matrix& m = inputs[0]->GetMatrix();
 153     Vector3 scale;
 154     Quaternion rot;
 155     m.GetTransformComponents(pos, rot, scale);
 156   }
 157 };
 158
 159 struct OrientationComponentConstraint
 160 {
 161   OrientationComponentConstraint(){}
 162
 163   void operator()( Quaternion& orientation, const PropertyInputContainer& inputs )
 164   {
 165     const Quaternion& parentOrientation = inputs[0]->GetQuaternion();
 166     Vector3 pos, scale;
 167     Quaternion rot;
 168     orientation = parentOrientation;
 169   }
 170 };
 171 // OnRelayout
 172
 173 static bool gOnRelayoutCallBackCalled = false;
 174 static std::vector< std::string > gActorNamesRelayout;
 175
 176 void OnRelayoutCallback( Actor actor )
 177 {
 178   gOnRelayoutCallBackCalled = true;
 179   gActorNamesRelayout.push_back( actor.GetName() );
 180 }
 181
 182 struct VisibilityChangedFunctorData
 183 {
 184   VisibilityChangedFunctorData()
 185   : actor(),
 186     visible( false ),
 187     type( DevelActor::VisibilityChange::SELF ),
 188     called( false )
 189   {
 190   }
 191
 192   void Reset()
 193   {
 194     actor.Reset();
 195     visible = false;
 196     type = DevelActor::VisibilityChange::SELF;
 197     called = false;
 198   }
 199
 200   void Check( bool compareCalled, Actor compareActor, bool compareVisible, DevelActor::VisibilityChange::Type compareType, const char * location )
 201   {
 202     DALI_TEST_EQUALS( called, compareCalled, TEST_INNER_LOCATION( location ) );
 203     DALI_TEST_EQUALS( actor, compareActor, TEST_INNER_LOCATION( location ) );
 204     DALI_TEST_EQUALS( visible, compareVisible, TEST_INNER_LOCATION( location ) );
 205     DALI_TEST_EQUALS( (int)type, (int)compareType, TEST_INNER_LOCATION( location ) );
 206   }
 207
 208   void Check( bool compareCalled, const std::string& location )
 209   {
 210     DALI_TEST_EQUALS( called, compareCalled, TEST_INNER_LOCATION( location ) );
 211   }
 212
 213   Actor actor;
 214   bool visible;
 215   DevelActor::VisibilityChange::Type type;
 216   bool called;
 217 };
 218
 219 struct VisibilityChangedFunctor
 220 {
 221   VisibilityChangedFunctor( VisibilityChangedFunctorData& dataVar ) : data( dataVar ) { }
 222
 223   void operator()( Actor actor, bool visible, DevelActor::VisibilityChange::Type type )
 224   {
 225     data.actor = actor;
 226     data.visible = visible;
 227     data.type = type;
 228     data.called = true;
 229   }
 230
 231   VisibilityChangedFunctorData& data;
 232 };
 233
 234
 235 struct VisibilityChangedVoidFunctor
 236 {
 237   VisibilityChangedVoidFunctor(bool& signalCalled)
 238   : mSignalCalled( signalCalled )
 239   { }
 240
 241   void operator()()
 242   {
 243     mSignalCalled  = true;
 244   }
 245
 246   bool& mSignalCalled;
 247 };
 248
 249 struct ChildOrderChangedFunctor
 250 {
 251   ChildOrderChangedFunctor(bool& signalCalled, Actor& actor)
 252   : mSignalCalled( signalCalled ),
 253     mActor( actor )
 254   { }
 255
 256   void operator()( Actor actor )
 257   {
 258     mSignalCalled  = true;
 259     mActor = actor;
 260   }
 261
 262   bool& mSignalCalled;
 263   Actor& mActor;
 264 };
 265
 266 struct CulledPropertyNotificationFunctor
 267 {
 268   CulledPropertyNotificationFunctor( bool& signalCalled, PropertyNotification& propertyNotification )
 269   : mSignalCalled( signalCalled ),
 270     mPropertyNotification( propertyNotification )
 271   { }
 272
 273   void operator()( PropertyNotification& source )
 274   {
 275     mSignalCalled  = true;
 276     mPropertyNotification = source;
 277   }
 278
 279   bool& mSignalCalled;
 280   PropertyNotification& mPropertyNotification;
 281 };
 282
 283 } // anonymous namespace
 284
 285
 286 //& purpose: Testing New API
 287 int UtcDaliActorNew(void)
 288 {
 289   TestApplication application;
 290
 291   Actor actor = Actor::New();
 292
 293   DALI_TEST_CHECK(actor);
 294   END_TEST;
 295 }
 296
 297 //& purpose: Testing Dali::Actor::DownCast()
 298 int UtcDaliActorDownCastP(void)
 299 {
 300   TestApplication application;
 301   tet_infoline("Testing Dali::Actor::DownCast()");
 302
 303   Actor actor = Actor::New();
 304   BaseHandle object(actor);
 305   Actor actor2 = Actor::DownCast(object);
 306   DALI_TEST_CHECK(actor2);
 307   END_TEST;
 308 }
 309
 310 //& purpose: Testing Dali::Actor::DownCast()
 311 int UtcDaliActorDownCastN(void)
 312 {
 313   TestApplication application;
 314   tet_infoline("Testing Dali::Actor::DownCast()");
 315
 316   BaseHandle unInitializedObject;
 317   Actor actor = Actor::DownCast(unInitializedObject);
 318   DALI_TEST_CHECK(!actor);
 319   END_TEST;
 320 }
 321
 322 //& purpose: Testing Dali::Actor::GetName()
 323 int UtcDaliActorGetName(void)
 324 {
 325   TestApplication application;
 326
 327   Actor actor = Actor::New();
 328
 329   DALI_TEST_CHECK(actor.GetName().empty());
 330   END_TEST;
 331 }
 332
 333 //& purpose: Testing Dali::Actor::SetName()
 334 int UtcDaliActorSetName(void)
 335 {
 336   TestApplication application;
 337
 338   string str("ActorName");
 339   Actor actor = Actor::New();
 340
 341   actor.SetName(str);
 342   DALI_TEST_CHECK(actor.GetName() == str);
 343   END_TEST;
 344 }
 345
 346 int UtcDaliActorGetId(void)
 347 {
 348   tet_infoline("Testing Dali::Actor::UtcDaliActorGetId()");
 349   TestApplication application;
 350
 351   Actor first = Actor::New();
 352   Actor second = Actor::New();
 353   Actor third = Actor::New();
 354
 355   DALI_TEST_CHECK(first.GetId() != second.GetId());
 356   DALI_TEST_CHECK(second.GetId() != third.GetId());
 357   END_TEST;
 358 }
 359
 360 int UtcDaliActorIsRoot(void)
 361 {
 362   TestApplication application;
 363
 364   Actor actor = Actor::New();
 365   DALI_TEST_CHECK(!actor.IsRoot());
 366
 367   // get the root layer
 368   actor = Stage::GetCurrent().GetLayer( 0 );
 369   DALI_TEST_CHECK( actor.IsRoot() );
 370   END_TEST;
 371 }
 372
 373 int UtcDaliActorOnStage(void)
 374 {
 375   TestApplication application;
 376
 377   Actor actor = Actor::New();
 378   DALI_TEST_CHECK( !actor.OnStage() );
 379
 380   // get the root layer
 381   actor = Stage::GetCurrent().GetLayer( 0 );
 382   DALI_TEST_CHECK( actor.OnStage() );
 383   END_TEST;
 384 }
 385
 386 int UtcDaliActorIsLayer(void)
 387 {
 388   TestApplication application;
 389
 390   Actor actor = Actor::New();
 391   DALI_TEST_CHECK( !actor.IsLayer() );
 392
 393   // get the root layer
 394   actor = Stage::GetCurrent().GetLayer( 0 );
 395   DALI_TEST_CHECK( actor.IsLayer() );
 396   END_TEST;
 397 }
 398
 399 int UtcDaliActorGetLayer(void)
 400 {
 401   TestApplication application;
 402
 403   Actor actor = Actor::New();
 404   Stage::GetCurrent().Add(actor);
 405   Layer layer = actor.GetLayer();
 406
 407   DALI_TEST_CHECK(layer);
 408
 409   // get the root layers layer
 410   actor = Stage::GetCurrent().GetLayer( 0 );
 411   DALI_TEST_CHECK( actor.GetLayer() );
 412   END_TEST;
 413 }
 414
 415 int UtcDaliActorAddP(void)
 416 {
 417   tet_infoline("Testing Actor::Add");
 418   TestApplication application;
 419
 420   Actor parent = Actor::New();
 421   Actor child = Actor::New();
 422
 423   DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
 424
 425   parent.Add(child);
 426
 427   DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
 428
 429   Actor parent2 = Actor::New();
 430   parent2.Add( child );
 431
 432   DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
 433   DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
 434
 435   // try Adding to same parent again, works
 436   parent2.Add( child );
 437   DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
 438
 439   // try reparenting an orphaned child
 440   {
 441     Actor temporaryParent = Actor::New();
 442     temporaryParent.Add( child );
 443     DALI_TEST_EQUALS( parent2.GetChildCount(), 0u, TEST_LOCATION );
 444   }
 445   // temporaryParent has now died, reparent the orphaned child
 446   parent2.Add( child );
 447   DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
 448
 449   END_TEST;
 450 }
 451
 452 int UtcDaliActorAddN(void)
 453 {
 454   tet_infoline("Testing Actor::Add");
 455   TestApplication application;
 456
 457   Actor child = Actor::New();
 458
 459   Actor parent2 = Actor::New();
 460   parent2.Add( child );
 461
 462   // try illegal Add
 463   try
 464   {
 465     parent2.Add( parent2 );
 466     tet_printf("Assertion test failed - no Exception\n" );
 467     tet_result(TET_FAIL);
 468   }
 469   catch(Dali::DaliException& e)
 470   {
 471     DALI_TEST_PRINT_ASSERT( e );
 472     DALI_TEST_ASSERT(e, "this != &child", TEST_LOCATION);
 473     DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
 474   }
 475   catch(...)
 476   {
 477     tet_printf("Assertion test failed - wrong Exception\n" );
 478     tet_result(TET_FAIL);
 479   }
 480
 481   // try reparenting root
 482   try
 483   {
 484     parent2.Add( Stage::GetCurrent().GetLayer( 0 ) );
 485     tet_printf("Assertion test failed - no Exception\n" );
 486     tet_result(TET_FAIL);
 487   }
 488   catch(Dali::DaliException& e)
 489   {
 490     DALI_TEST_PRINT_ASSERT( e );
 491     DALI_TEST_ASSERT(e, "!child.IsRoot()", TEST_LOCATION);
 492     DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
 493   }
 494   catch(...)
 495   {
 496     tet_printf("Assertion test failed - wrong Exception\n" );
 497     tet_result(TET_FAIL);
 498   }
 499
 500   // try Add empty
 501   try
 502   {
 503     Actor empty;
 504     parent2.Add( empty );
 505     tet_printf("Assertion test failed - no Exception\n" );
 506     tet_result(TET_FAIL);
 507   }
 508   catch(Dali::DaliException& e)
 509   {
 510     DALI_TEST_PRINT_ASSERT( e );
 511     DALI_TEST_ASSERT(e, "actor", TEST_LOCATION);
 512     DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
 513   }
 514   catch(...)
 515   {
 516     tet_printf("Assertion test failed - wrong Exception\n" );
 517     tet_result(TET_FAIL);
 518   }
 519
 520   END_TEST;
 521 }
 522
 523 int UtcDaliActorRemoveN(void)
 524 {
 525   tet_infoline("Testing Actor::Remove");
 526   TestApplication application;
 527
 528   Actor parent = Actor::New();
 529   Actor child = Actor::New();
 530   DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
 531
 532   parent.Add(child);
 533   DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
 534
 535   parent.Remove(child);
 536   DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
 537
 538   // remove again, no problem
 539   parent.Remove(child);
 540   DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
 541
 542   // add child back
 543   parent.Add(child);
 544   DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
 545   // try Remove self, its a no-op
 546   parent.Remove( parent );
 547   DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
 548
 549   // try Remove empty
 550   try
 551   {
 552     Actor empty;
 553     parent.Remove( empty );
 554     tet_printf("Assertion test failed - no Exception\n" );
 555     tet_result(TET_FAIL);
 556   }
 557   catch(Dali::DaliException& e)
 558   {
 559     DALI_TEST_PRINT_ASSERT( e );
 560     DALI_TEST_ASSERT(e, "actor", TEST_LOCATION);
 561     DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
 562   }
 563   catch(...)
 564   {
 565     tet_printf("Assertion test failed - wrong Exception\n" );
 566     tet_result(TET_FAIL);
 567   }
 568   END_TEST;
 569 }
 570
 571 int UtcDaliActorRemoveP(void)
 572 {
 573   TestApplication application;
 574
 575   Actor parent = Actor::New();
 576   Actor child = Actor::New();
 577   Actor random = Actor::New();
 578
 579   Stage::GetCurrent().Add( parent );
 580
 581   DALI_TEST_CHECK(parent.GetChildCount() == 0);
 582
 583   parent.Add(child);
 584
 585   DALI_TEST_CHECK(parent.GetChildCount() == 1);
 586
 587   parent.Remove(random);
 588
 589   DALI_TEST_CHECK(parent.GetChildCount() == 1);
 590
 591   Stage::GetCurrent().Remove( parent );
 592
 593   DALI_TEST_CHECK(parent.GetChildCount() == 1);
 594   END_TEST;
 595 }
 596
 597 int UtcDaliActorGetChildCount(void)
 598 {
 599   TestApplication application;
 600
 601   Actor parent = Actor::New();
 602   Actor child = Actor::New();
 603
 604   DALI_TEST_CHECK(parent.GetChildCount() == 0);
 605
 606   parent.Add(child);
 607
 608   DALI_TEST_CHECK(parent.GetChildCount() == 1);
 609   END_TEST;
 610 }
 611
 612 int UtcDaliActorGetChildren01(void)
 613 {
 614   TestApplication application;
 615
 616   Actor parent = Actor::New();
 617   Actor first  = Actor::New();
 618   Actor second = Actor::New();
 619   Actor third  = Actor::New();
 620
 621   parent.Add(first);
 622   parent.Add(second);
 623   parent.Add(third);
 624
 625   DALI_TEST_CHECK(parent.GetChildAt(0) == first);
 626   DALI_TEST_CHECK(parent.GetChildAt(1) == second);
 627   DALI_TEST_CHECK(parent.GetChildAt(2) == third);
 628   END_TEST;
 629 }
 630
 631 int UtcDaliActorGetChildren02(void)
 632 {
 633   TestApplication application;
 634
 635   Actor parent = Actor::New();
 636   Actor first  = Actor::New();
 637   Actor second = Actor::New();
 638   Actor third  = Actor::New();
 639
 640   parent.Add(first);
 641   parent.Add(second);
 642   parent.Add(third);
 643
 644   const Actor& constParent = parent;
 645
 646   DALI_TEST_CHECK(constParent.GetChildAt(0) == first);
 647   DALI_TEST_CHECK(constParent.GetChildAt(1) == second);
 648   DALI_TEST_CHECK(constParent.GetChildAt(2) == third);
 649   END_TEST;
 650 }
 651
 652 int UtcDaliActorGetParent01(void)
 653 {
 654   TestApplication application;
 655
 656   Actor parent = Actor::New();
 657   Actor child = Actor::New();
 658
 659   parent.Add(child);
 660
 661   DALI_TEST_CHECK(child.GetParent() == parent);
 662   END_TEST;
 663 }
 664
 665 int UtcDaliActorGetParent02(void)
 666 {
 667   TestApplication application;
 668
 669   Actor actor = Actor::New();
 670
 671   DALI_TEST_CHECK(!actor.GetParent());
 672   END_TEST;
 673 }
 674
 675 int UtcDaliActorCustomProperty(void)
 676 {
 677   TestApplication application;
 678
 679   Actor actor = Actor::New();
 680   Stage::GetCurrent().Add( actor );
 681
 682   float startValue(1.0f);
 683   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
 684   DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
 685
 686   application.SendNotification();
 687   application.Render(0);
 688   DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
 689
 690   actor.SetProperty( index, 5.0f );
 691
 692   application.SendNotification();
 693   application.Render(0);
 694   DALI_TEST_CHECK( actor.GetProperty<float>(index) == 5.0f );
 695   END_TEST;
 696 }
 697
 698 int UtcDaliActorCustomPropertyIntToFloat(void)
 699 {
 700   TestApplication application;
 701
 702   Actor actor = Actor::New();
 703   Stage::GetCurrent().Add( actor );
 704
 705   float startValue(5.0f);
 706   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
 707   DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
 708
 709   application.SendNotification();
 710   application.Render(0);
 711   DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
 712
 713   actor.SetProperty( index, int(1) );
 714
 715   application.SendNotification();
 716   application.Render(0);
 717   DALI_TEST_CHECK( actor.GetProperty<float>(index) == 1.0f );
 718   END_TEST;
 719 }
 720
 721 int UtcDaliActorCustomPropertyFloatToInt(void)
 722 {
 723   TestApplication application;
 724
 725   Actor actor = Actor::New();
 726   Stage::GetCurrent().Add( actor );
 727
 728   int startValue(5);
 729   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
 730   DALI_TEST_CHECK( actor.GetProperty<int>(index) == startValue );
 731
 732   application.SendNotification();
 733   application.Render(0);
 734   DALI_TEST_CHECK( actor.GetProperty<int>(index) == startValue );
 735
 736   actor.SetProperty( index, float(1.5) );
 737
 738   application.SendNotification();
 739   application.Render(0);
 740   DALI_TEST_CHECK( actor.GetProperty<int>(index) == 1 );
 741   END_TEST;
 742 }
 743
 744 int UtcDaliActorSetParentOrigin(void)
 745 {
 746   TestApplication application;
 747
 748   Actor actor = Actor::New();
 749
 750   Vector3 vector(0.7f, 0.8f, 0.9f);
 751   DALI_TEST_CHECK(vector != actor.GetCurrentParentOrigin());
 752
 753   actor.SetParentOrigin(vector);
 754
 755   // flush the queue and render once
 756   application.SendNotification();
 757   application.Render();
 758
 759   DALI_TEST_CHECK(vector == actor.GetCurrentParentOrigin());
 760
 761   Stage::GetCurrent().Add( actor );
 762
 763   actor.SetParentOrigin( Vector3( 0.1f, 0.2f, 0.3f ) );
 764
 765   // flush the queue and render once
 766   application.SendNotification();
 767   application.Render();
 768
 769   DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentParentOrigin(), TEST_LOCATION );
 770
 771   Stage::GetCurrent().Remove( actor );
 772   END_TEST;
 773 }
 774
 775 int UtcDaliActorSetParentOriginIndividual(void)
 776 {
 777   TestApplication application;
 778
 779   Actor actor = Actor::New();
 780
 781   Vector3 vector(0.7f, 0.8f, 0.9f);
 782   DALI_TEST_CHECK(vector != actor.GetCurrentParentOrigin());
 783
 784   actor.SetProperty( Actor::Property::PARENT_ORIGIN_X, vector.x );
 785
 786   // flush the queue and render once
 787   application.SendNotification();
 788   application.Render();
 789
 790   DALI_TEST_EQUALS( vector.x, actor.GetCurrentParentOrigin().x, TEST_LOCATION );
 791
 792   actor.SetProperty( Actor::Property::PARENT_ORIGIN_Y, vector.y );
 793
 794   // flush the queue and render once
 795   application.SendNotification();
 796   application.Render();
 797
 798   DALI_TEST_EQUALS( vector.y, actor.GetCurrentParentOrigin().y, TEST_LOCATION );
 799
 800   actor.SetProperty( Actor::Property::PARENT_ORIGIN_Z, vector.z );
 801
 802   // flush the queue and render once
 803   application.SendNotification();
 804   application.Render();
 805
 806   DALI_TEST_EQUALS( vector.z, actor.GetCurrentParentOrigin().z, TEST_LOCATION );
 807
 808   END_TEST;
 809 }
 810
 811 int UtcDaliActorGetCurrentParentOrigin(void)
 812 {
 813   TestApplication application;
 814
 815   Actor actor = Actor::New();
 816
 817   Vector3 vector(0.7f, 0.8f, 0.9f);
 818   DALI_TEST_CHECK(vector != actor.GetCurrentParentOrigin());
 819
 820   actor.SetParentOrigin(vector);
 821
 822   // flush the queue and render once
 823   application.SendNotification();
 824   application.Render();
 825
 826   DALI_TEST_CHECK(vector == actor.GetCurrentParentOrigin());
 827   END_TEST;
 828 }
 829
 830 int UtcDaliActorSetAnchorPoint(void)
 831 {
 832   TestApplication application;
 833
 834   Actor actor = Actor::New();
 835
 836   Vector3 vector(0.7f, 0.8f, 0.9f);
 837   DALI_TEST_CHECK(vector != actor.GetCurrentAnchorPoint());
 838
 839   actor.SetAnchorPoint(vector);
 840
 841   // flush the queue and render once
 842   application.SendNotification();
 843   application.Render();
 844
 845   DALI_TEST_CHECK(vector == actor.GetCurrentAnchorPoint());
 846
 847   Stage::GetCurrent().Add( actor );
 848
 849   actor.SetAnchorPoint( Vector3( 0.1f, 0.2f, 0.3f ) );
 850   // flush the queue and render once
 851   application.SendNotification();
 852   application.Render();
 853
 854   DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentAnchorPoint(), TEST_LOCATION );
 855
 856   Stage::GetCurrent().Remove( actor );
 857   END_TEST;
 858 }
 859
 860 int UtcDaliActorSetAnchorPointIndividual(void)
 861 {
 862   TestApplication application;
 863
 864   Actor actor = Actor::New();
 865
 866   Vector3 vector(0.7f, 0.8f, 0.9f);
 867   DALI_TEST_CHECK(vector != actor.GetCurrentAnchorPoint());
 868
 869   actor.SetProperty( Actor::Property::ANCHOR_POINT_X, vector.x );
 870
 871   // flush the queue and render once
 872   application.SendNotification();
 873   application.Render();
 874
 875   DALI_TEST_EQUALS( vector.x, actor.GetCurrentAnchorPoint().x, TEST_LOCATION );
 876
 877   actor.SetProperty( Actor::Property::ANCHOR_POINT_Y, vector.y );
 878
 879   // flush the queue and render once
 880   application.SendNotification();
 881   application.Render();
 882
 883   DALI_TEST_EQUALS( vector.y, actor.GetCurrentAnchorPoint().y, TEST_LOCATION );
 884
 885   actor.SetProperty( Actor::Property::ANCHOR_POINT_Z, vector.z );
 886
 887   // flush the queue and render once
 888   application.SendNotification();
 889   application.Render();
 890
 891   DALI_TEST_EQUALS( vector.z, actor.GetCurrentAnchorPoint().z, TEST_LOCATION );
 892
 893   END_TEST;
 894 }
 895
 896 int UtcDaliActorGetCurrentAnchorPoint(void)
 897 {
 898   TestApplication application;
 899
 900   Actor actor = Actor::New();
 901
 902   Vector3 vector(0.7f, 0.8f, 0.9f);
 903   DALI_TEST_CHECK(vector != actor.GetCurrentAnchorPoint());
 904
 905   actor.SetAnchorPoint(vector);
 906
 907   // flush the queue and render once
 908   application.SendNotification();
 909   application.Render();
 910
 911   DALI_TEST_CHECK(vector == actor.GetCurrentAnchorPoint());
 912   END_TEST;
 913 }
 914
 915 // SetSize(float width, float height)
 916 int UtcDaliActorSetSize01(void)
 917 {
 918   TestApplication application;
 919
 920   Actor actor = Actor::New();
 921   Vector3 vector(100.0f, 100.0f, 0.0f);
 922
 923   DALI_TEST_CHECK(vector != actor.GetCurrentSize());
 924
 925   actor.SetSize(vector.x, vector.y);
 926
 927   // Immediately retrieve the size after setting
 928   Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
 929   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
 930   DALI_TEST_EQUALS( vector.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
 931   DALI_TEST_EQUALS( vector.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
 932   DALI_TEST_EQUALS( vector.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
 933
 934   // Flush the queue and render once
 935   application.SendNotification();
 936   application.Render();
 937
 938   // Check the size in the new frame
 939   DALI_TEST_CHECK(vector == actor.GetCurrentSize());
 940
 941   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
 942   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
 943   DALI_TEST_EQUALS( vector.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
 944   DALI_TEST_EQUALS( vector.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
 945   DALI_TEST_EQUALS( vector.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
 946
 947   // Check async behaviour
 948   currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
 949   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
 950   DALI_TEST_EQUALS( vector.width, actor.GetCurrentProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
 951   DALI_TEST_EQUALS( vector.height, actor.GetCurrentProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
 952   DALI_TEST_EQUALS( vector.depth, actor.GetCurrentProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
 953
 954   // Change the resize policy and check whether the size stays the same
 955   actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
 956
 957   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
 958   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
 959
 960   // Set a new size after resize policy is changed and check the new size
 961   actor.SetSize( Vector3( 0.1f, 0.2f, 0.0f ) );
 962
 963   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
 964   DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.0f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
 965
 966   // Change the resize policy again and check whether the new size stays the same
 967   actor.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
 968
 969   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
 970   DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.0f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
 971
 972   // Set another new size after resize policy is changed and check the new size
 973   actor.SetSize( Vector3( 50.0f, 60.0f, 0.0f ) );
 974
 975   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
 976   DALI_TEST_EQUALS( currentSize, Vector3( 50.0f, 60.0f, 0.0f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
 977
 978   END_TEST;
 979 }
 980
 981 // SetSize(float width, float height, float depth)
 982 int UtcDaliActorSetSize02(void)
 983 {
 984   TestApplication application;
 985
 986   Actor actor = Actor::New();
 987   Vector3 vector(100.0f, 100.0f, 100.0f);
 988
 989   DALI_TEST_CHECK(vector != actor.GetCurrentSize());
 990
 991   actor.SetSize(vector.x, vector.y, vector.z);
 992
 993   // Immediately check the size after setting
 994   Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
 995   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
 996
 997   // flush the queue and render once
 998   application.SendNotification();
 999   application.Render();
1000
1001   // Check the size in the new frame
1002   DALI_TEST_CHECK(vector == actor.GetCurrentSize());
1003
1004   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
1005   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1006
1007   END_TEST;
1008 }
1009
1010 // SetSize(Vector2 size)
1011 int UtcDaliActorSetSize03(void)
1012 {
1013   TestApplication application;
1014
1015   Actor actor = Actor::New();
1016   Vector3 vector(100.0f, 100.0f, 0.0f);
1017
1018   DALI_TEST_CHECK(vector != actor.GetCurrentSize());
1019
1020   actor.SetSize(Vector2(vector.x, vector.y));
1021
1022   // Immediately check the size after setting
1023   Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
1024   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1025
1026   // flush the queue and render once
1027   application.SendNotification();
1028   application.Render();
1029
1030   // Check the size in the new frame
1031   DALI_TEST_CHECK(vector == actor.GetCurrentSize());
1032
1033   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
1034   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1035
1036   END_TEST;
1037 }
1038
1039 // SetSize(Vector3 size)
1040 int UtcDaliActorSetSize04(void)
1041 {
1042   TestApplication application;
1043
1044   Actor actor = Actor::New();
1045   Vector3 vector(100.0f, 100.0f, 100.0f);
1046
1047   DALI_TEST_CHECK(vector != actor.GetCurrentSize());
1048
1049   actor.SetSize(vector);
1050
1051   // Immediately check the size after setting
1052   Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
1053   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1054
1055   // flush the queue and render once
1056   application.SendNotification();
1057   application.Render();
1058
1059   // Check the size in the new frame
1060   DALI_TEST_CHECK(vector == actor.GetCurrentSize());
1061
1062   Stage::GetCurrent().Add( actor );
1063   actor.SetSize( Vector3( 0.1f, 0.2f, 0.3f ) );
1064
1065   // Immediately check the size after setting
1066   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
1067   DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.3f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
1068
1069   // flush the queue and render once
1070   application.SendNotification();
1071   application.Render();
1072
1073   // Check the size in the new frame
1074   DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentSize(), TEST_LOCATION );
1075
1076   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
1077   DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.3f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
1078
1079   Stage::GetCurrent().Remove( actor );
1080   END_TEST;
1081 }
1082
1083 int UtcDaliActorSetSizeIndividual(void)
1084 {
1085   TestApplication application;
1086
1087   Actor actor = Actor::New();
1088
1089   Vector3 vector(0.7f, 0.8f, 0.9f);
1090   DALI_TEST_CHECK(vector != actor.GetCurrentSize());
1091
1092   actor.SetProperty( Actor::Property::SIZE_WIDTH, vector.width );
1093
1094   // Immediately check the width after setting
1095   float sizeWidth = actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >();
1096   DALI_TEST_EQUALS( sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1097
1098   // flush the queue and render once
1099   application.SendNotification();
1100   application.Render();
1101
1102   // Check the width in the new frame
1103   DALI_TEST_EQUALS( vector.width, actor.GetCurrentSize().width, TEST_LOCATION );
1104
1105   sizeWidth = actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >();
1106   DALI_TEST_EQUALS( sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1107
1108   actor.SetProperty( Actor::Property::SIZE_HEIGHT, vector.height );
1109
1110   // Immediately check the height after setting
1111   float sizeHeight = actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >();
1112   DALI_TEST_EQUALS( sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1113
1114   // flush the queue and render once
1115   application.SendNotification();
1116   application.Render();
1117
1118   // Check the height in the new frame
1119   DALI_TEST_EQUALS( vector.height, actor.GetCurrentSize().height, TEST_LOCATION );
1120
1121   sizeHeight = actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >();
1122   DALI_TEST_EQUALS( sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1123
1124   actor.SetProperty( Actor::Property::SIZE_DEPTH, vector.depth );
1125
1126   // Immediately check the depth after setting
1127   float sizeDepth = actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >();
1128   DALI_TEST_EQUALS( sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1129
1130   // flush the queue and render once
1131   application.SendNotification();
1132   application.Render();
1133
1134   // Check the depth in the new frame
1135   DALI_TEST_EQUALS( vector.depth, actor.GetCurrentSize().depth, TEST_LOCATION );
1136
1137   sizeDepth = actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >();
1138   DALI_TEST_EQUALS( sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1139
1140   // Change the resize policy and check whether the size stays the same
1141   actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
1142
1143   sizeWidth = actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >();
1144   DALI_TEST_EQUALS( sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1145
1146   sizeHeight = actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >();
1147   DALI_TEST_EQUALS( sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1148
1149   sizeDepth = actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >();
1150   DALI_TEST_EQUALS( sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1151
1152   // Change the resize policy again and check whether the size stays the same
1153   actor.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
1154
1155   sizeWidth = actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >();
1156   DALI_TEST_EQUALS( sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1157
1158   sizeHeight = actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >();
1159   DALI_TEST_EQUALS( sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1160
1161   sizeDepth = actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >();
1162   DALI_TEST_EQUALS( sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1163
1164   END_TEST;
1165 }
1166
1167 int UtcDaliActorSetSizeIndividual02(void)
1168 {
1169   TestApplication application;
1170
1171   Actor actor = Actor::New();
1172   actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
1173   Stage::GetCurrent().Add( actor );
1174
1175   Vector3 vector( 100.0f, 200.0f, 400.0f );
1176   DALI_TEST_CHECK( vector != actor.GetCurrentSize() );
1177
1178   actor.SetProperty( Actor::Property::SIZE_WIDTH, vector.width );
1179   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >(), vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1180
1181   actor.SetProperty( Actor::Property::SIZE_HEIGHT, vector.height );
1182   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >(), vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1183
1184   actor.SetProperty( Actor::Property::SIZE_DEPTH, vector.depth );
1185   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >(), vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1186
1187   // flush the queue and render once
1188   application.SendNotification();
1189   application.Render();
1190
1191   // Check the width in the new frame
1192   DALI_TEST_EQUALS( vector.width, actor.GetCurrentSize().width, TEST_LOCATION );
1193   DALI_TEST_EQUALS( vector.height, actor.GetCurrentSize().height, TEST_LOCATION );
1194
1195   END_TEST;
1196 }
1197
1198
1199 int UtcDaliActorGetCurrentSize(void)
1200 {
1201   TestApplication application;
1202
1203   Actor actor = Actor::New();
1204   Vector3 vector(100.0f, 100.0f, 20.0f);
1205
1206   DALI_TEST_CHECK(vector != actor.GetCurrentSize());
1207
1208   actor.SetSize(vector);
1209
1210   // flush the queue and render once
1211   application.SendNotification();
1212   application.Render();
1213
1214   DALI_TEST_CHECK(vector == actor.GetCurrentSize());
1215   END_TEST;
1216 }
1217
1218 int UtcDaliActorGetNaturalSize(void)
1219 {
1220   TestApplication application;
1221
1222   Actor actor = Actor::New();
1223   Vector3 vector( 0.0f, 0.0f, 0.0f );
1224
1225   DALI_TEST_CHECK( actor.GetNaturalSize() == vector );
1226
1227   END_TEST;
1228 }
1229
1230 int UtcDaliActorGetCurrentSizeImmediate(void)
1231 {
1232   TestApplication application;
1233
1234   Actor actor = Actor::New();
1235   Vector3 vector(100.0f, 100.0f, 20.0f);
1236
1237   DALI_TEST_CHECK(vector != actor.GetTargetSize());
1238   DALI_TEST_CHECK(vector != actor.GetCurrentSize());
1239
1240   actor.SetSize(vector);
1241
1242   DALI_TEST_CHECK(vector == actor.GetTargetSize());
1243   DALI_TEST_CHECK(vector != actor.GetCurrentSize());
1244
1245   // flush the queue and render once
1246   application.SendNotification();
1247   application.Render();
1248
1249   DALI_TEST_CHECK(vector == actor.GetTargetSize());
1250   DALI_TEST_CHECK(vector == actor.GetCurrentSize());
1251
1252   // Animation
1253   // Build the animation
1254   const float durationSeconds = 2.0f;
1255   Animation animation = Animation::New( durationSeconds );
1256   const Vector3 targetValue( 10.0f, 20.0f, 30.0f );
1257   animation.AnimateTo( Property( actor, Actor::Property::SIZE ), targetValue );
1258
1259   DALI_TEST_CHECK( actor.GetTargetSize() == vector );
1260
1261   // Start the animation
1262   animation.Play();
1263
1264   application.SendNotification();
1265   application.Render( static_cast<unsigned int>( durationSeconds * 1000.0f ) );
1266
1267   DALI_TEST_CHECK( actor.GetTargetSize() == targetValue );
1268
1269   END_TEST;
1270 }
1271
1272 int UtcDaliActorCalculateScreenExtents(void)
1273 {
1274   TestApplication application;
1275
1276   Actor actor = Actor::New();
1277
1278   actor.SetPosition(Vector3(2.0f, 2.0f, 16.0f));
1279   actor.SetSize(Vector3{ 1.0f, 1.0f, 1.0f });
1280
1281   application.SendNotification();
1282   application.Render();
1283
1284   auto expectedExtent = Rect<>{ -0.5f, -0.5f, 1.0f, 1.0f };
1285   auto actualExtent = DevelActor::CalculateScreenExtents( actor );
1286   DALI_TEST_EQUALS( expectedExtent.x, actualExtent.x, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
1287   DALI_TEST_EQUALS( expectedExtent.y, actualExtent.y, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
1288   DALI_TEST_EQUALS( expectedExtent.width, actualExtent.width, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
1289   DALI_TEST_EQUALS( expectedExtent.height, actualExtent.height, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
1290
1291   Stage::GetCurrent().Remove( actor );
1292   END_TEST;
1293 }
1294
1295 // SetPosition(float x, float y)
1296 int UtcDaliActorSetPosition01(void)
1297 {
1298   TestApplication application;
1299
1300   Actor actor = Actor::New();
1301
1302   // Set to random to start off with
1303   actor.SetPosition(Vector3(120.0f, 120.0f, 0.0f));
1304
1305   Vector3 vector(100.0f, 100.0f, 0.0f);
1306
1307   DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
1308
1309   actor.SetPosition(vector.x, vector.y);
1310   // flush the queue and render once
1311   application.SendNotification();
1312   application.Render();
1313   DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
1314
1315   Stage::GetCurrent().Add( actor );
1316   actor.SetPosition( Vector3( 0.1f, 0.2f, 0.3f ) );
1317   // flush the queue and render once
1318   application.SendNotification();
1319   application.Render();
1320   DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentPosition(), TEST_LOCATION );
1321
1322   actor.SetX( 1.0f );
1323   actor.SetY( 1.1f );
1324   actor.SetZ( 1.2f );
1325   // flush the queue and render once
1326   application.SendNotification();
1327   application.Render();
1328   DALI_TEST_EQUALS( Vector3( 1.0f, 1.1f, 1.2f ), actor.GetCurrentPosition(), TEST_LOCATION );
1329
1330   actor.TranslateBy( Vector3( 0.1f, 0.1f, 0.1f ) );
1331   // flush the queue and render once
1332   application.SendNotification();
1333   application.Render();
1334   DALI_TEST_EQUALS( Vector3( 1.1f, 1.2f, 1.3f ), actor.GetCurrentPosition(), Math::MACHINE_EPSILON_10000, TEST_LOCATION );
1335
1336   Stage::GetCurrent().Remove( actor );
1337   END_TEST;
1338 }
1339
1340 // SetPosition(float x, float y, float z)
1341 int UtcDaliActorSetPosition02(void)
1342 {
1343   TestApplication application;
1344
1345   Actor actor = Actor::New();
1346
1347   // Set to random to start off with
1348   actor.SetPosition(Vector3(120.0f, 120.0f, 120.0f));
1349
1350   Vector3 vector(100.0f, 100.0f, 100.0f);
1351
1352   DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
1353
1354   actor.SetPosition(vector.x, vector.y, vector.z);
1355
1356   // flush the queue and render once
1357   application.SendNotification();
1358   application.Render();
1359
1360   DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
1361   END_TEST;
1362 }
1363
1364 // SetPosition(Vector3 position)
1365 int UtcDaliActorSetPosition03(void)
1366 {
1367   TestApplication application;
1368
1369   Actor actor = Actor::New();
1370
1371   // Set to random to start off with
1372   actor.SetPosition(Vector3(120.0f, 120.0f, 120.0f));
1373
1374   Vector3 vector(100.0f, 100.0f, 100.0f);
1375
1376   DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
1377
1378   actor.SetPosition(vector);
1379
1380   // flush the queue and render once
1381   application.SendNotification();
1382   application.Render();
1383
1384   DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
1385   END_TEST;
1386 }
1387
1388 int UtcDaliActorSetX(void)
1389 {
1390   TestApplication application;
1391
1392   Actor actor = Actor::New();
1393
1394   Vector3 vector(100.0f, 0.0f, 0.0f);
1395
1396   DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
1397
1398   actor.SetX(100.0f);
1399
1400   // flush the queue and render once
1401   application.SendNotification();
1402   application.Render();
1403
1404   DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
1405   END_TEST;
1406 }
1407
1408 int UtcDaliActorSetY(void)
1409 {
1410   TestApplication application;
1411
1412   Actor actor = Actor::New();
1413
1414   Vector3 vector(0.0f, 100.0f, 0.0f);
1415
1416   DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
1417
1418   actor.SetY(100.0f);
1419
1420   // flush the queue and render once
1421   application.SendNotification();
1422   application.Render();
1423
1424   DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
1425   END_TEST;
1426 }
1427
1428 int UtcDaliActorSetZ(void)
1429 {
1430   TestApplication application;
1431
1432   Actor actor = Actor::New();
1433
1434   Vector3 vector(0.0f, 0.0f, 100.0f);
1435
1436   DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
1437
1438   actor.SetZ(100.0f);
1439
1440   // flush the queue and render once
1441   application.SendNotification();
1442   application.Render();
1443
1444   DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
1445   END_TEST;
1446 }
1447
1448 int UtcDaliActorSetPositionProperties(void)
1449 {
1450   TestApplication application;
1451
1452   Actor actor = Actor::New();
1453
1454   Vector3 vector(0.7f, 0.8f, 0.9f);
1455   DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
1456
1457   actor.SetProperty( Actor::Property::POSITION_X, vector.x );
1458   DALI_TEST_EQUALS( vector.x, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).x, TEST_LOCATION );
1459   DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::POSITION_X ), TEST_LOCATION );
1460
1461   // flush the queue and render once
1462   application.SendNotification();
1463   application.Render();
1464
1465   DALI_TEST_EQUALS( vector.x, actor.GetCurrentPosition().x, TEST_LOCATION );
1466   DALI_TEST_EQUALS( vector.x, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).x, TEST_LOCATION );
1467   DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::POSITION_X ), TEST_LOCATION );
1468   DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).x, TEST_LOCATION );
1469   DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< float >( Actor::Property::POSITION_X ), TEST_LOCATION );
1470
1471   actor.SetProperty( Actor::Property::POSITION_Y, vector.y );
1472   DALI_TEST_EQUALS( vector.y, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).y, TEST_LOCATION );
1473   DALI_TEST_EQUALS( vector.y, actor.GetProperty< float >( Actor::Property::POSITION_Y ), TEST_LOCATION );
1474
1475   // flush the queue and render once
1476   application.SendNotification();
1477   application.Render();
1478
1479   DALI_TEST_EQUALS( vector.y, actor.GetCurrentPosition().y, TEST_LOCATION );
1480   DALI_TEST_EQUALS( vector.y, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).y, TEST_LOCATION );
1481   DALI_TEST_EQUALS( vector.y, actor.GetProperty< float >( Actor::Property::POSITION_Y ), TEST_LOCATION );
1482   DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).y, TEST_LOCATION );
1483   DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< float >( Actor::Property::POSITION_Y ), TEST_LOCATION );
1484
1485   actor.SetProperty( Actor::Property::POSITION_Z, vector.z );
1486   DALI_TEST_EQUALS( vector.z, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).z, TEST_LOCATION );
1487   DALI_TEST_EQUALS( vector.z, actor.GetProperty< float >( Actor::Property::POSITION_Z ), TEST_LOCATION );
1488
1489   // flush the queue and render once
1490   application.SendNotification();
1491   application.Render();
1492
1493   DALI_TEST_EQUALS( vector.z, actor.GetCurrentPosition().z, TEST_LOCATION );
1494   DALI_TEST_EQUALS( vector.z, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).z, TEST_LOCATION );
1495   DALI_TEST_EQUALS( vector.z, actor.GetProperty< float >( Actor::Property::POSITION_Z ), TEST_LOCATION );
1496   DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).z, TEST_LOCATION );
1497   DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< float >( Actor::Property::POSITION_Z ), TEST_LOCATION );
1498
1499   END_TEST;
1500 }
1501
1502 int UtcDaliActorTranslateBy(void)
1503 {
1504   TestApplication application;
1505
1506   Actor actor = Actor::New();
1507   Vector3 vector(100.0f, 100.0f, 100.0f);
1508
1509   DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
1510
1511   actor.SetPosition(vector);
1512
1513   // flush the queue and render once
1514   application.SendNotification();
1515   application.Render();
1516
1517   DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
1518
1519   actor.TranslateBy(vector);
1520
1521   // flush the queue and render once
1522   application.SendNotification();
1523   application.Render();
1524
1525   DALI_TEST_CHECK(vector*2.0f == actor.GetCurrentPosition());
1526   END_TEST;
1527 }
1528
1529 int UtcDaliActorGetCurrentPosition(void)
1530 {
1531   TestApplication application;
1532
1533   Actor actor = Actor::New();
1534   Vector3 setVector(100.0f, 100.0f, 0.0f);
1535   actor.SetPosition(setVector);
1536
1537   // flush the queue and render once
1538   application.SendNotification();
1539   application.Render();
1540
1541   DALI_TEST_CHECK(actor.GetCurrentPosition() == setVector);
1542   END_TEST;
1543 }
1544
1545 int UtcDaliActorGetCurrentWorldPosition(void)
1546 {
1547   TestApplication application;
1548
1549   Actor parent = Actor::New();
1550   Vector3 parentPosition( 1.0f, 2.0f, 3.0f );
1551   parent.SetPosition( parentPosition );
1552   parent.SetParentOrigin( ParentOrigin::CENTER );
1553   parent.SetAnchorPoint( AnchorPoint::CENTER );
1554   Stage::GetCurrent().Add( parent );
1555
1556   Actor child = Actor::New();
1557   child.SetParentOrigin( ParentOrigin::CENTER );
1558   child.SetAnchorPoint( AnchorPoint::CENTER );
1559   Vector3 childPosition( 6.0f, 6.0f, 6.0f );
1560   child.SetPosition( childPosition );
1561   parent.Add( child );
1562
1563   // The actors should not have a world position yet
1564   DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), Vector3::ZERO, TEST_LOCATION );
1565   DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), Vector3::ZERO, TEST_LOCATION );
1566
1567   application.SendNotification();
1568   application.Render(0);
1569
1570   DALI_TEST_EQUALS( parent.GetCurrentPosition(), parentPosition, TEST_LOCATION );
1571   DALI_TEST_EQUALS( child.GetCurrentPosition(), childPosition, TEST_LOCATION );
1572
1573   // The actors should have a world position now
1574   DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), parentPosition, TEST_LOCATION );
1575   DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), parentPosition + childPosition, TEST_LOCATION );
1576   END_TEST;
1577 }
1578
1579 int UtcDaliActorSetInheritPosition(void)
1580 {
1581   tet_infoline("Testing Actor::SetInheritPosition");
1582   TestApplication application;
1583
1584   Actor parent = Actor::New();
1585   Vector3 parentPosition( 1.0f, 2.0f, 3.0f );
1586   parent.SetPosition( parentPosition );
1587   parent.SetParentOrigin( ParentOrigin::CENTER );
1588   parent.SetAnchorPoint( AnchorPoint::CENTER );
1589   Stage::GetCurrent().Add( parent );
1590
1591   Actor child = Actor::New();
1592   child.SetParentOrigin( ParentOrigin::CENTER );
1593   child.SetAnchorPoint( AnchorPoint::CENTER );
1594   Vector3 childPosition( 10.0f, 11.0f, 12.0f );
1595   child.SetPosition( childPosition );
1596   parent.Add( child );
1597
1598   // The actors should not have a world position yet
1599   DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), Vector3::ZERO, TEST_LOCATION );
1600   DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), Vector3::ZERO, TEST_LOCATION );
1601
1602   // first test default, which is to inherit position
1603   DALI_TEST_EQUALS( child.IsPositionInherited(), true, TEST_LOCATION );
1604   application.SendNotification();
1605   application.Render(0); // should only really call Update as Render is not required to update scene
1606   DALI_TEST_EQUALS( parent.GetCurrentPosition(), parentPosition, TEST_LOCATION );
1607   DALI_TEST_EQUALS( child.GetCurrentPosition(), childPosition, TEST_LOCATION );
1608   DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), parentPosition, TEST_LOCATION );
1609   DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), parentPosition + childPosition, TEST_LOCATION );
1610
1611   //Change child position
1612   Vector3 childOffset( -1.0f, 1.0f, 0.0f );
1613   child.SetPosition( childOffset );
1614
1615   // Use local position as world postion
1616   child.SetInheritPosition( false );
1617   DALI_TEST_EQUALS( child.IsPositionInherited(), false, TEST_LOCATION );
1618   application.SendNotification();
1619   application.Render(0); // should only really call Update as Render is not required to update scene
1620   DALI_TEST_EQUALS( parent.GetCurrentPosition(), parentPosition, TEST_LOCATION );
1621   DALI_TEST_EQUALS( child.GetCurrentPosition(), childOffset, TEST_LOCATION );
1622   DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), parentPosition, TEST_LOCATION );
1623   DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), childOffset, TEST_LOCATION );
1624
1625   //Change back to inherit position from parent
1626   child.SetInheritPosition( true );
1627   DALI_TEST_EQUALS( child.IsPositionInherited(), true, TEST_LOCATION );
1628   application.SendNotification();
1629   application.Render(0); // should only really call Update as Render is not required to update scene
1630   DALI_TEST_EQUALS( parent.GetCurrentPosition(), parentPosition, TEST_LOCATION );
1631   DALI_TEST_EQUALS( child.GetCurrentPosition(), childOffset, TEST_LOCATION );
1632   DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), parentPosition, TEST_LOCATION );
1633   DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), parentPosition + childOffset, TEST_LOCATION );
1634   END_TEST;
1635 }
1636
1637 int UtcDaliActorInheritOpacity(void)
1638 {
1639   tet_infoline("Testing Actor::Inherit Opacity");
1640   TestApplication application;
1641
1642   Actor parent = Actor::New();
1643   Actor child = Actor::New();
1644   parent.Add( child );
1645   Stage::GetCurrent().Add( parent );
1646
1647   DALI_TEST_EQUALS( parent.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION );
1648   DALI_TEST_EQUALS( child.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION );
1649
1650   // flush the queue and render once
1651   application.SendNotification();
1652   application.Render();
1653
1654   parent.SetOpacity( 0.1f );
1655
1656   DALI_TEST_EQUALS( parent.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 0.1f, 0.0001f, TEST_LOCATION );
1657   DALI_TEST_EQUALS( child.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION );
1658
1659   application.SendNotification();
1660   application.Render();
1661
1662   DALI_TEST_EQUALS( parent.GetProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
1663   DALI_TEST_EQUALS( parent.GetCurrentProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 0.1f, 0.0001f, TEST_LOCATION );
1664   DALI_TEST_EQUALS( parent.GetCurrentProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
1665   DALI_TEST_EQUALS( child.GetProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
1666   DALI_TEST_EQUALS( child.GetCurrentProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
1667   DALI_TEST_EQUALS( child.GetCurrentProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.f, 0.0001f, TEST_LOCATION );
1668
1669   END_TEST;
1670 }
1671
1672 // SetOrientation(float angleRadians, Vector3 axis)
1673 int UtcDaliActorSetOrientation01(void)
1674 {
1675   TestApplication application;
1676
1677   Quaternion rotation( Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
1678   Actor actor = Actor::New();
1679
1680   actor.SetOrientation(rotation);
1681
1682   // flush the queue and render once
1683   application.SendNotification();
1684   application.Render();
1685
1686   DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1687   END_TEST;
1688 }
1689
1690 int UtcDaliActorSetOrientation02(void)
1691 {
1692   TestApplication application;
1693
1694   Actor actor = Actor::New();
1695
1696   Radian angle( 0.785f );
1697   Vector3 axis(1.0f, 1.0f, 0.0f);
1698
1699   actor.SetOrientation( angle, axis);
1700   Quaternion rotation( angle, axis );
1701   // flush the queue and render once
1702   application.SendNotification();
1703   application.Render();
1704   DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1705
1706   Stage::GetCurrent().Add( actor );
1707   actor.RotateBy( Degree( 360 ), axis);
1708   DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1709
1710   actor.SetOrientation( Degree( 0 ), Vector3( 1.0f, 0.0f, 0.0f ) );
1711   Quaternion result( Radian( 0 ), Vector3( 1.0f, 0.0f, 0.0f ) );
1712   // flush the queue and render once
1713   application.SendNotification();
1714   application.Render();
1715   DALI_TEST_EQUALS( result, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1716
1717   actor.SetOrientation( angle, axis);
1718   // flush the queue and render once
1719   application.SendNotification();
1720   application.Render();
1721   DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1722
1723   Stage::GetCurrent().Remove( actor );
1724   END_TEST;
1725 }
1726
1727 // SetOrientation(float angleRadians, Vector3 axis)
1728 int UtcDaliActorSetOrientationProperty(void)
1729 {
1730   TestApplication application;
1731
1732   Quaternion rotation( Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
1733   Actor actor = Actor::New();
1734
1735   actor.SetProperty( Actor::Property::ORIENTATION, rotation );
1736   DALI_TEST_EQUALS(rotation, actor.GetProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
1737
1738   // flush the queue and render once
1739   application.SendNotification();
1740   application.Render();
1741
1742   DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1743   DALI_TEST_EQUALS(rotation, actor.GetProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
1744   DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
1745   END_TEST;
1746 }
1747
1748 // RotateBy(float angleRadians, Vector3 axis)
1749 int UtcDaliActorRotateBy01(void)
1750 {
1751   TestApplication application;
1752
1753   Actor actor = Actor::New();
1754
1755   Radian angle( M_PI * 0.25f );
1756   actor.RotateBy(( angle ), Vector3::ZAXIS);
1757   // flush the queue and render once
1758   application.SendNotification();
1759   application.Render();
1760   DALI_TEST_EQUALS(Quaternion( angle, Vector3::ZAXIS), actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1761
1762   Stage::GetCurrent().Add( actor );
1763
1764   actor.RotateBy( angle, Vector3::ZAXIS);
1765   // flush the queue and render once
1766   application.SendNotification();
1767   application.Render();
1768   DALI_TEST_EQUALS(Quaternion(angle * 2.0f, Vector3::ZAXIS), actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1769
1770   Stage::GetCurrent().Remove( actor );
1771   END_TEST;
1772 }
1773
1774 // RotateBy(Quaternion relativeRotation)
1775 int UtcDaliActorRotateBy02(void)
1776 {
1777   TestApplication application;
1778
1779   Actor actor = Actor::New();
1780
1781   Radian angle( M_PI * 0.25f );
1782   Quaternion rotation(angle, Vector3::ZAXIS);
1783   actor.RotateBy(rotation);
1784   // flush the queue and render once
1785   application.SendNotification();
1786   application.Render();
1787   DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1788
1789   actor.RotateBy(rotation);
1790   // flush the queue and render once
1791   application.SendNotification();
1792   application.Render();
1793   DALI_TEST_EQUALS(Quaternion(angle * 2.0f, Vector3::ZAXIS), actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1794   END_TEST;
1795 }
1796
1797 int UtcDaliActorGetCurrentOrientation(void)
1798 {
1799   TestApplication application;
1800   Actor actor = Actor::New();
1801
1802   Quaternion rotation(Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
1803   actor.SetOrientation(rotation);
1804   // flush the queue and render once
1805   application.SendNotification();
1806   application.Render();
1807   DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1808   END_TEST;
1809 }
1810
1811 int UtcDaliActorGetCurrentWorldOrientation(void)
1812 {
1813   tet_infoline("Testing Actor::GetCurrentWorldRotation");
1814   TestApplication application;
1815
1816   Actor parent = Actor::New();
1817   Radian rotationAngle( Degree(90.0f) );
1818   Quaternion rotation( rotationAngle, Vector3::YAXIS );
1819   parent.SetOrientation( rotation );
1820   Stage::GetCurrent().Add( parent );
1821
1822   Actor child = Actor::New();
1823   child.SetOrientation( rotation );
1824   parent.Add( child );
1825
1826   // The actors should not have a world rotation yet
1827   DALI_TEST_EQUALS( parent.GetCurrentWorldOrientation(), Quaternion(Radian(0.0f), Vector3::YAXIS), 0.001, TEST_LOCATION );
1828   DALI_TEST_EQUALS( child.GetCurrentWorldOrientation(), Quaternion(Radian(0.0f), Vector3::YAXIS), 0.001, TEST_LOCATION );
1829
1830   application.SendNotification();
1831   application.Render(0);
1832
1833   DALI_TEST_EQUALS( parent.GetCurrentOrientation(), rotation, 0.001, TEST_LOCATION );
1834   DALI_TEST_EQUALS( child.GetCurrentOrientation(), rotation, 0.001, TEST_LOCATION );
1835
1836   // The actors should have a world rotation now
1837   DALI_TEST_EQUALS( parent.GetCurrentWorldOrientation(), Quaternion( rotationAngle, Vector3::YAXIS ), 0.001, TEST_LOCATION );
1838   DALI_TEST_EQUALS( child.GetCurrentWorldOrientation(), Quaternion( rotationAngle * 2.0f, Vector3::YAXIS ), 0.001, TEST_LOCATION );
1839
1840   // turn off child rotation inheritance
1841   child.SetInheritOrientation( false );
1842   DALI_TEST_EQUALS( child.IsOrientationInherited(), false, TEST_LOCATION );
1843   application.SendNotification();
1844   application.Render(0);
1845
1846   // The actors should have a world rotation now
1847   DALI_TEST_EQUALS( parent.GetCurrentWorldOrientation(), Quaternion( rotationAngle, Vector3::YAXIS ), 0.001, TEST_LOCATION );
1848   DALI_TEST_EQUALS( child.GetCurrentWorldOrientation(), rotation, 0.001, TEST_LOCATION );
1849   END_TEST;
1850 }
1851
1852 // SetScale(float scale)
1853 int UtcDaliActorSetScale01(void)
1854 {
1855   TestApplication application;
1856
1857   Actor actor = Actor::New();
1858
1859   // Set to random value first - GetCurrentScale() asserts if called before SetScale()
1860   actor.SetScale(0.25f);
1861
1862   Vector3 scale(10.0f, 10.0f, 10.0f);
1863   DALI_TEST_CHECK(actor.GetCurrentScale() != scale);
1864
1865   actor.SetScale(scale.x);
1866
1867   // flush the queue and render once
1868   application.SendNotification();
1869   application.Render();
1870
1871   DALI_TEST_CHECK(actor.GetCurrentScale() == scale);
1872   END_TEST;
1873 }
1874
1875 // SetScale(float scaleX, float scaleY, float scaleZ)
1876 int UtcDaliActorSetScale02(void)
1877 {
1878   TestApplication application;
1879   Vector3 scale(10.0f, 10.0f, 10.0f);
1880
1881   Actor actor = Actor::New();
1882
1883   // Set to random value first - GetCurrentScale() asserts if called before SetScale()
1884   actor.SetScale(Vector3(12.0f, 1.0f, 2.0f));
1885
1886   DALI_TEST_CHECK(actor.GetCurrentScale() != scale);
1887
1888   actor.SetScale(scale.x, scale.y, scale.z);
1889   // flush the queue and render once
1890   application.SendNotification();
1891   application.Render();
1892   DALI_TEST_CHECK(actor.GetCurrentScale() == scale);
1893
1894   // add to stage and test
1895   Stage::GetCurrent().Add( actor );
1896   actor.SetScale( 2.0f, 2.0f, 2.0f );
1897   // flush the queue and render once
1898   application.SendNotification();
1899   application.Render();
1900   DALI_TEST_EQUALS( Vector3( 2.0f, 2.0f, 2.0f ), actor.GetCurrentScale(), 0.001, TEST_LOCATION);
1901
1902   Stage::GetCurrent().Remove( actor );
1903
1904   END_TEST;
1905 }
1906
1907 // SetScale(Vector3 scale)
1908 int UtcDaliActorSetScale03(void)
1909 {
1910   TestApplication application;
1911   Vector3 scale(10.0f, 10.0f, 10.0f);
1912
1913   Actor actor = Actor::New();
1914
1915   // Set to random value first - GetCurrentScale() asserts if called before SetScale()
1916   actor.SetScale(Vector3(12.0f, 1.0f, 2.0f));
1917
1918   DALI_TEST_CHECK(actor.GetCurrentScale() != scale);
1919
1920   actor.SetScale(scale);
1921
1922   // flush the queue and render once
1923   application.SendNotification();
1924   application.Render();
1925
1926   DALI_TEST_CHECK(actor.GetCurrentScale() == scale);
1927   END_TEST;
1928 }
1929
1930 int UtcDaliActorSetScaleIndividual(void)
1931 {
1932   TestApplication application;
1933
1934   Actor actor = Actor::New();
1935
1936   Vector3 vector(0.7f, 0.8f, 0.9f);
1937   DALI_TEST_CHECK(vector != actor.GetCurrentScale());
1938
1939   actor.SetProperty( Actor::Property::SCALE_X, vector.x );
1940   DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::SCALE_X ), TEST_LOCATION );
1941
1942   // flush the queue and render once
1943   application.SendNotification();
1944   application.Render();
1945
1946   DALI_TEST_EQUALS( vector.x, actor.GetCurrentScale().x, TEST_LOCATION );
1947   DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::SCALE_X ), TEST_LOCATION );
1948   DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< float >( Actor::Property::SCALE_X ), TEST_LOCATION );
1949
1950   actor.SetProperty( Actor::Property::SCALE_Y, vector.y );
1951   DALI_TEST_EQUALS( vector.y, actor.GetProperty< float >( Actor::Property::SCALE_Y ), TEST_LOCATION );
1952
1953   // flush the queue and render once
1954   application.SendNotification();
1955   application.Render();
1956
1957   DALI_TEST_EQUALS( vector.y, actor.GetCurrentScale().y, TEST_LOCATION );
1958   DALI_TEST_EQUALS( vector.y, actor.GetProperty< float >( Actor::Property::SCALE_Y ), TEST_LOCATION );
1959   DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< float >( Actor::Property::SCALE_Y ), TEST_LOCATION );
1960
1961   actor.SetProperty( Actor::Property::SCALE_Z, vector.z );
1962   DALI_TEST_EQUALS( vector.z, actor.GetProperty< float >( Actor::Property::SCALE_Z ), TEST_LOCATION );
1963
1964   // flush the queue and render once
1965   application.SendNotification();
1966   application.Render();
1967
1968   DALI_TEST_EQUALS( vector.z, actor.GetCurrentScale().z, TEST_LOCATION );
1969   DALI_TEST_EQUALS( vector.z, actor.GetProperty< float >( Actor::Property::SCALE_Z ), TEST_LOCATION );
1970   DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< float >( Actor::Property::SCALE_Z ), TEST_LOCATION );
1971
1972   DALI_TEST_EQUALS( vector, actor.GetProperty< Vector3 >( Actor::Property::SCALE ), TEST_LOCATION );
1973   DALI_TEST_EQUALS( vector, actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), TEST_LOCATION );
1974
1975   END_TEST;
1976 }
1977
1978 int UtcDaliActorScaleBy(void)
1979 {
1980   TestApplication application;
1981   Actor actor = Actor::New();
1982   Vector3 vector(100.0f, 100.0f, 100.0f);
1983
1984   DALI_TEST_CHECK(vector != actor.GetCurrentScale());
1985
1986   actor.SetScale(vector);
1987
1988   // flush the queue and render once
1989   application.SendNotification();
1990   application.Render();
1991
1992   DALI_TEST_CHECK(vector == actor.GetCurrentScale());
1993
1994   actor.ScaleBy(vector);
1995
1996   // flush the queue and render once
1997   application.SendNotification();
1998   application.Render();
1999
2000   DALI_TEST_CHECK(vector*100.0f == actor.GetCurrentScale());
2001   END_TEST;
2002 }
2003
2004 int UtcDaliActorGetCurrentScale(void)
2005 {
2006   TestApplication application;
2007   Vector3 scale(12.0f, 1.0f, 2.0f);
2008
2009   Actor actor = Actor::New();
2010
2011   actor.SetScale(scale);
2012
2013   // flush the queue and render once
2014   application.SendNotification();
2015   application.Render();
2016
2017   DALI_TEST_CHECK(actor.GetCurrentScale() == scale);
2018   END_TEST;
2019 }
2020
2021 int UtcDaliActorGetCurrentWorldScale(void)
2022 {
2023   TestApplication application;
2024
2025   Actor parent = Actor::New();
2026   Vector3 parentScale( 1.0f, 2.0f, 3.0f );
2027   parent.SetScale( parentScale );
2028   Stage::GetCurrent().Add( parent );
2029
2030   Actor child = Actor::New();
2031   Vector3 childScale( 2.0f, 2.0f, 2.0f );
2032   child.SetScale( childScale );
2033   parent.Add( child );
2034
2035   // The actors should not have a scale yet
2036   DALI_TEST_EQUALS( parent.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
2037   DALI_TEST_EQUALS( child.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
2038
2039   // The actors should not have a world scale yet
2040   DALI_TEST_EQUALS( parent.GetCurrentWorldScale(), Vector3::ONE, TEST_LOCATION );
2041   DALI_TEST_EQUALS( child.GetCurrentWorldScale(), Vector3::ONE, TEST_LOCATION );
2042
2043   application.SendNotification();
2044   application.Render(0);
2045
2046   DALI_TEST_EQUALS( parent.GetCurrentScale(), parentScale, TEST_LOCATION );
2047   DALI_TEST_EQUALS( child.GetCurrentScale(), childScale, TEST_LOCATION );
2048
2049   // The actors should have a world scale now
2050   DALI_TEST_EQUALS( parent.GetCurrentWorldScale(), parentScale, TEST_LOCATION );
2051   DALI_TEST_EQUALS( child.GetCurrentWorldScale(), parentScale * childScale, TEST_LOCATION );
2052   END_TEST;
2053 }
2054
2055 int UtcDaliActorInheritScale(void)
2056 {
2057   tet_infoline("Testing Actor::SetInheritScale");
2058   TestApplication application;
2059
2060   Actor parent = Actor::New();
2061   Vector3 parentScale( 1.0f, 2.0f, 3.0f );
2062   parent.SetScale( parentScale );
2063   Stage::GetCurrent().Add( parent );
2064
2065   Actor child = Actor::New();
2066   Vector3 childScale( 2.0f, 2.0f, 2.0f );
2067   child.SetScale( childScale );
2068   parent.Add( child );
2069
2070   application.SendNotification();
2071   application.Render(0);
2072
2073   DALI_TEST_EQUALS( child.IsScaleInherited(), true, TEST_LOCATION );
2074   DALI_TEST_EQUALS( child.GetCurrentWorldScale(), parentScale * childScale, TEST_LOCATION );
2075
2076   child.SetInheritScale( false );
2077   DALI_TEST_EQUALS( child.IsScaleInherited(), false, TEST_LOCATION );
2078
2079   application.SendNotification();
2080   application.Render(0);
2081
2082   DALI_TEST_EQUALS( child.GetCurrentWorldScale(), childScale, TEST_LOCATION );
2083   END_TEST;
2084 }
2085
2086 int UtcDaliActorSetVisible(void)
2087 {
2088   TestApplication application;
2089
2090   Actor actor = Actor::New();
2091   actor.SetVisible(false);
2092   // flush the queue and render once
2093   application.SendNotification();
2094   application.Render();
2095   DALI_TEST_CHECK(actor.IsVisible() == false);
2096
2097   actor.SetVisible(true);
2098   // flush the queue and render once
2099   application.SendNotification();
2100   application.Render();
2101   DALI_TEST_CHECK(actor.IsVisible() == true);
2102
2103   // put actor on stage
2104   Stage::GetCurrent().Add( actor );
2105   actor.SetVisible(false);
2106   // flush the queue and render once
2107   application.SendNotification();
2108   application.Render();
2109   DALI_TEST_CHECK(actor.IsVisible() == false);
2110   END_TEST;
2111 }
2112
2113 int UtcDaliActorIsVisible(void)
2114 {
2115   TestApplication application;
2116
2117   Actor actor = Actor::New();
2118
2119   DALI_TEST_CHECK(actor.IsVisible() == true);
2120   END_TEST;
2121 }
2122
2123 int UtcDaliActorSetOpacity(void)
2124 {
2125   TestApplication application;
2126
2127   Actor actor = Actor::New();
2128   // initial opacity is 1
2129   DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 1.0f, TEST_LOCATION );
2130
2131   actor.SetOpacity( 0.4f);
2132   // flush the queue and render once
2133   application.SendNotification();
2134   application.Render();
2135   DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 0.4f, TEST_LOCATION );
2136
2137   // change opacity, actor is on stage to change is not immediate
2138   actor.SetOpacity( actor.GetCurrentOpacity() + 0.1f );
2139   // flush the queue and render once
2140   application.SendNotification();
2141   application.Render();
2142   DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 0.5f, TEST_LOCATION );
2143
2144   // put actor on stage
2145   Stage::GetCurrent().Add( actor );
2146
2147   // change opacity, actor is on stage to change is not immediate
2148   actor.SetOpacity( 0.9f );
2149   DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 0.5f, TEST_LOCATION );
2150   // flush the queue and render once
2151   application.SendNotification();
2152   application.Render();
2153   DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 0.9f, TEST_LOCATION );
2154
2155   // change opacity, actor is on stage to change is not immediate
2156   actor.SetOpacity( actor.GetCurrentOpacity() - 0.9f );
2157   // flush the queue and render once
2158   application.SendNotification();
2159   application.Render();
2160   DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 0.0f, TEST_LOCATION );
2161   END_TEST;
2162 }
2163
2164 int UtcDaliActorGetCurrentOpacity(void)
2165 {
2166   TestApplication application;
2167
2168   Actor actor = Actor::New();
2169   DALI_TEST_CHECK(actor.GetCurrentOpacity() != 0.5f);
2170
2171   actor.SetOpacity(0.5f);
2172   // flush the queue and render once
2173   application.SendNotification();
2174   application.Render();
2175   DALI_TEST_CHECK(actor.GetCurrentOpacity() == 0.5f);
2176   END_TEST;
2177 }
2178
2179 int UtcDaliActorSetSensitive(void)
2180 {
2181   TestApplication application;
2182   Actor actor = Actor::New();
2183
2184   bool sensitive = !actor.IsSensitive();
2185
2186   actor.SetSensitive(sensitive);
2187
2188   DALI_TEST_CHECK(sensitive == actor.IsSensitive());
2189   END_TEST;
2190 }
2191
2192 int UtcDaliActorIsSensitive(void)
2193 {
2194   TestApplication application;
2195   Actor actor = Actor::New();
2196   actor.SetSensitive(false);
2197
2198   DALI_TEST_CHECK(false == actor.IsSensitive());
2199   END_TEST;
2200 }
2201
2202 int UtcDaliActorSetColor(void)
2203 {
2204   TestApplication application;
2205   Actor actor = Actor::New();
2206   Vector4 color(1.0f, 1.0f, 1.0f, 0.5f);
2207
2208   DALI_TEST_CHECK(color != actor.GetCurrentColor());
2209
2210   actor.SetColor(color);
2211   // flush the queue and render once
2212   application.SendNotification();
2213   application.Render();
2214   DALI_TEST_CHECK(color == actor.GetCurrentColor());
2215
2216   actor.SetColor( actor.GetCurrentColor() + Vector4( -0.4f, -0.5f, -0.6f, -0.4f ) );
2217   // flush the queue and render once
2218   application.SendNotification();
2219   application.Render();
2220   DALI_TEST_EQUALS( Vector4( 0.6f, 0.5f, 0.4f, 0.1f ), actor.GetCurrentColor(),  TEST_LOCATION );
2221
2222   Stage::GetCurrent().Add( actor );
2223   actor.SetColor( color );
2224   // flush the queue and render once
2225   application.SendNotification();
2226   application.Render();
2227   DALI_TEST_EQUALS( color, actor.GetCurrentColor(),  TEST_LOCATION );
2228
2229   actor.SetColor( actor.GetCurrentColor() + Vector4( 1.1f, 1.1f, 1.1f, 1.1f ) );
2230   // flush the queue and render once
2231   application.SendNotification();
2232   application.Render();
2233   // Actor color is not clamped
2234   DALI_TEST_EQUALS( Vector4( 2.1f, 2.1f, 2.1f, 1.6f ), actor.GetCurrentColor(),  TEST_LOCATION );
2235   // world color is clamped
2236   DALI_TEST_EQUALS( Vector4( 1.0f, 1.0f, 1.0f, 1.0f ), actor.GetCurrentWorldColor(),  TEST_LOCATION );
2237
2238   Stage::GetCurrent().Remove( actor );
2239   END_TEST;
2240 }
2241
2242 int UtcDaliActorSetColorIndividual(void)
2243 {
2244   TestApplication application;
2245
2246   Actor actor = Actor::New();
2247
2248   Vector4 vector(0.7f, 0.8f, 0.9f, 0.6f);
2249   DALI_TEST_CHECK(vector != actor.GetCurrentColor());
2250
2251   actor.SetProperty( Actor::Property::COLOR_RED, vector.r );
2252   DALI_TEST_EQUALS( vector.r, actor.GetProperty< float >( Actor::Property::COLOR_RED ), TEST_LOCATION );
2253
2254   // flush the queue and render once
2255   application.SendNotification();
2256   application.Render();
2257
2258   DALI_TEST_EQUALS( vector.r, actor.GetCurrentColor().r, TEST_LOCATION );
2259   DALI_TEST_EQUALS( vector.r, actor.GetProperty< float >( Actor::Property::COLOR_RED ), TEST_LOCATION );
2260   DALI_TEST_EQUALS( vector.r, actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), TEST_LOCATION );
2261
2262   actor.SetProperty( Actor::Property::COLOR_GREEN, vector.g );
2263   DALI_TEST_EQUALS( vector.g, actor.GetProperty< float >( Actor::Property::COLOR_GREEN ), TEST_LOCATION );
2264
2265   // flush the queue and render once
2266   application.SendNotification();
2267   application.Render();
2268
2269   DALI_TEST_EQUALS( vector.g, actor.GetCurrentColor().g, TEST_LOCATION );
2270   DALI_TEST_EQUALS( vector.g, actor.GetProperty< float >( Actor::Property::COLOR_GREEN ), TEST_LOCATION );
2271   DALI_TEST_EQUALS( vector.g, actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), TEST_LOCATION );
2272
2273   actor.SetProperty( Actor::Property::COLOR_BLUE, vector.b );
2274   DALI_TEST_EQUALS( vector.b, actor.GetProperty< float >( Actor::Property::COLOR_BLUE ), TEST_LOCATION );
2275
2276   // flush the queue and render once
2277   application.SendNotification();
2278   application.Render();
2279
2280   DALI_TEST_EQUALS( vector.b, actor.GetCurrentColor().b, TEST_LOCATION );
2281   DALI_TEST_EQUALS( vector.b, actor.GetProperty< float >( Actor::Property::COLOR_BLUE ), TEST_LOCATION );
2282   DALI_TEST_EQUALS( vector.b, actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), TEST_LOCATION );
2283
2284
2285   actor.SetProperty( Actor::Property::COLOR_ALPHA, vector.a );
2286   DALI_TEST_EQUALS( vector.a, actor.GetProperty< float >( Actor::Property::COLOR_ALPHA ), TEST_LOCATION );
2287
2288   // flush the queue and render once
2289   application.SendNotification();
2290   application.Render();
2291
2292   DALI_TEST_EQUALS( vector.a, actor.GetCurrentColor().a, TEST_LOCATION );
2293   DALI_TEST_EQUALS( vector.a, actor.GetProperty< float >( Actor::Property::COLOR_ALPHA ), TEST_LOCATION );
2294   DALI_TEST_EQUALS( vector.a, actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), TEST_LOCATION );
2295
2296   DALI_TEST_EQUALS( vector, actor.GetProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION );
2297   DALI_TEST_EQUALS( vector, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION );
2298
2299   actor.SetProperty( DevelActor::Property::OPACITY, 0.2f );
2300
2301
2302   // flush the queue and render once
2303   application.SendNotification();
2304   application.Render();
2305
2306   DALI_TEST_EQUALS( 0.2f, actor.GetCurrentColor().a, TEST_LOCATION );
2307
2308   END_TEST;
2309 }
2310
2311
2312 int UtcDaliActorGetCurrentColor(void)
2313 {
2314   TestApplication application;
2315   Actor actor = Actor::New();
2316   Vector4 color(1.0f, 1.0f, 1.0f, 0.5f);
2317
2318   actor.SetColor(color);
2319   // flush the queue and render once
2320   application.SendNotification();
2321   application.Render();
2322   DALI_TEST_CHECK(color == actor.GetCurrentColor());
2323   END_TEST;
2324 }
2325
2326 int UtcDaliActorGetCurrentWorldColor(void)
2327 {
2328   tet_infoline("Actor::GetCurrentWorldColor");
2329   TestApplication application;
2330
2331   Actor parent = Actor::New();
2332   Vector4 parentColor( 1.0f, 0.5f, 0.0f, 0.8f );
2333   parent.SetColor( parentColor );
2334   Stage::GetCurrent().Add( parent );
2335
2336   Actor child = Actor::New();
2337   Vector4 childColor( 0.5f, 0.6f, 0.5f, 1.0f );
2338   child.SetColor( childColor );
2339   parent.Add( child );
2340
2341   DALI_TEST_EQUALS( parent.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
2342   DALI_TEST_EQUALS( child.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
2343
2344   // verify the default color mode
2345   DALI_TEST_EQUALS( USE_OWN_MULTIPLY_PARENT_ALPHA, child.GetColorMode(), TEST_LOCATION );
2346
2347   // The actors should not have a world color yet
2348   DALI_TEST_EQUALS( parent.GetCurrentWorldColor(), Color::WHITE, TEST_LOCATION );
2349   DALI_TEST_EQUALS( child.GetCurrentWorldColor(), Color::WHITE, TEST_LOCATION );
2350
2351   application.SendNotification();
2352   application.Render(0);
2353
2354   DALI_TEST_EQUALS( parent.GetCurrentColor(), parentColor, TEST_LOCATION );
2355   DALI_TEST_EQUALS( child.GetCurrentColor(), childColor, TEST_LOCATION );
2356
2357   // The actors should have a world color now
2358   DALI_TEST_EQUALS( parent.GetCurrentWorldColor(), parentColor, TEST_LOCATION );
2359   DALI_TEST_EQUALS( child.GetCurrentWorldColor(), Vector4( childColor.r, childColor.g, childColor.b, childColor.a * parentColor.a), TEST_LOCATION );
2360
2361   // use own color
2362   child.SetColorMode( USE_OWN_COLOR );
2363   application.SendNotification();
2364   application.Render(0);
2365   DALI_TEST_EQUALS( child.GetCurrentWorldColor(), childColor, TEST_LOCATION );
2366
2367   // use parent color
2368   child.SetColorMode( USE_PARENT_COLOR );
2369   application.SendNotification();
2370   application.Render(0);
2371   DALI_TEST_EQUALS( child.GetCurrentColor(), childColor, TEST_LOCATION );
2372   DALI_TEST_EQUALS( child.GetCurrentWorldColor(), parentColor, TEST_LOCATION );
2373
2374   // use parent alpha
2375   child.SetColorMode( USE_OWN_MULTIPLY_PARENT_ALPHA );
2376   application.SendNotification();
2377   application.Render(0);
2378   Vector4 expectedColor( childColor );
2379   expectedColor.a *= parentColor.a;
2380   DALI_TEST_EQUALS( child.GetCurrentColor(), childColor, TEST_LOCATION );
2381   DALI_TEST_EQUALS( child.GetCurrentWorldColor(), expectedColor, TEST_LOCATION );
2382   END_TEST;
2383 }
2384
2385 int UtcDaliActorSetColorMode(void)
2386 {
2387   tet_infoline("Actor::SetColorMode");
2388   TestApplication application;
2389   Actor actor = Actor::New();
2390   Actor child = Actor::New();
2391   actor.Add( child );
2392
2393   actor.SetColorMode( USE_OWN_COLOR );
2394   DALI_TEST_EQUALS( USE_OWN_COLOR, actor.GetColorMode(), TEST_LOCATION );
2395
2396   actor.SetColorMode( USE_OWN_MULTIPLY_PARENT_COLOR );
2397   DALI_TEST_EQUALS( USE_OWN_MULTIPLY_PARENT_COLOR, actor.GetColorMode(), TEST_LOCATION );
2398
2399   actor.SetColorMode( USE_PARENT_COLOR );
2400   DALI_TEST_EQUALS( USE_PARENT_COLOR, actor.GetColorMode(), TEST_LOCATION );
2401
2402   actor.SetColorMode( USE_OWN_MULTIPLY_PARENT_ALPHA );
2403   DALI_TEST_EQUALS( USE_OWN_MULTIPLY_PARENT_ALPHA, actor.GetColorMode(), TEST_LOCATION );
2404   END_TEST;
2405 }
2406
2407 int UtcDaliActorScreenToLocal(void)
2408 {
2409   TestApplication application;
2410   Actor actor = Actor::New();
2411   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
2412   actor.SetSize(100.0f, 100.0f);
2413   actor.SetPosition(10.0f, 10.0f);
2414   Stage::GetCurrent().Add(actor);
2415
2416   // flush the queue and render once
2417   application.SendNotification();
2418   application.Render();
2419
2420   float localX;
2421   float localY;
2422
2423   application.SendNotification();
2424   application.Render();
2425
2426   DALI_TEST_CHECK( actor.ScreenToLocal(localX, localY, 50.0f, 50.0f) );
2427
2428   DALI_TEST_EQUALS(localX, 40.0f, 0.01f, TEST_LOCATION);
2429   DALI_TEST_EQUALS(localY, 40.0f, 0.01f, TEST_LOCATION);
2430   END_TEST;
2431 }
2432
2433 int UtcDaliActorSetLeaveRequired(void)
2434 {
2435   TestApplication application;
2436
2437   Actor actor = Actor::New();
2438
2439   actor.SetLeaveRequired(false);
2440   DALI_TEST_CHECK(actor.GetLeaveRequired() == false);
2441
2442   actor.SetLeaveRequired(true);
2443   DALI_TEST_CHECK(actor.GetLeaveRequired() == true);
2444   END_TEST;
2445 }
2446
2447 int UtcDaliActorGetLeaveRequired(void)
2448 {
2449   TestApplication application;
2450
2451   Actor actor = Actor::New();
2452
2453   DALI_TEST_CHECK(actor.GetLeaveRequired() == false);
2454   END_TEST;
2455 }
2456
2457 int UtcDaliActorSetKeyboardFocusable(void)
2458 {
2459   TestApplication application;
2460
2461   Actor actor = Actor::New();
2462
2463   actor.SetKeyboardFocusable(true);
2464   DALI_TEST_CHECK(actor.IsKeyboardFocusable() == true);
2465
2466   actor.SetKeyboardFocusable(false);
2467   DALI_TEST_CHECK(actor.IsKeyboardFocusable() == false);
2468   END_TEST;
2469 }
2470
2471 int UtcDaliActorIsKeyboardFocusable(void)
2472 {
2473   TestApplication application;
2474
2475   Actor actor = Actor::New();
2476
2477   DALI_TEST_CHECK(actor.IsKeyboardFocusable() == false);
2478   END_TEST;
2479 }
2480
2481 int UtcDaliActorRemoveConstraints(void)
2482 {
2483   tet_infoline(" UtcDaliActorRemoveConstraints");
2484   TestApplication application;
2485
2486   gTestConstraintCalled = false;
2487
2488   Actor actor = Actor::New();
2489
2490   Constraint constraint = Constraint::New<Vector4>( actor, Actor::Property::COLOR, TestConstraint() );
2491   constraint.Apply();
2492   actor.RemoveConstraints();
2493
2494   DALI_TEST_CHECK( gTestConstraintCalled == false );
2495
2496   Stage::GetCurrent().Add( actor );
2497   constraint.Apply();
2498
2499   // flush the queue and render once
2500   application.SendNotification();
2501   application.Render();
2502
2503   actor.RemoveConstraints();
2504
2505   DALI_TEST_CHECK( gTestConstraintCalled == true );
2506   END_TEST;
2507 }
2508
2509 int UtcDaliActorRemoveConstraintTag(void)
2510 {
2511   tet_infoline(" UtcDaliActorRemoveConstraintTag");
2512   TestApplication application;
2513
2514   Actor actor = Actor::New();
2515
2516   // 1. Apply Constraint1 and Constraint2, and test...
2517   unsigned int result1 = 0u;
2518   unsigned int result2 = 0u;
2519
2520   unsigned constraint1Tag = 1u;
2521   Constraint constraint1 = Constraint::New<Vector4>( actor, Actor::Property::COLOR, TestConstraintRef<Vector4>(result1, 1) );
2522   constraint1.SetTag( constraint1Tag );
2523   constraint1.Apply();
2524
2525   unsigned constraint2Tag = 2u;
2526   Constraint constraint2 = Constraint::New<Vector4>( actor, Actor::Property::COLOR, TestConstraintRef<Vector4>(result2, 2) );
2527   constraint2.SetTag( constraint2Tag );
2528   constraint2.Apply();
2529
2530   Stage::GetCurrent().Add( actor );
2531   // flush the queue and render once
2532   application.SendNotification();
2533   application.Render();
2534
2535   DALI_TEST_EQUALS( result1, 1u, TEST_LOCATION );
2536   DALI_TEST_EQUALS( result2, 2u, TEST_LOCATION );
2537
2538   // 2. Remove Constraint1 and test...
2539   result1 = 0;
2540   result2 = 0;
2541   actor.RemoveConstraints(constraint1Tag);
2542   // make color property dirty, which will trigger constraints to be reapplied.
2543   actor.SetColor( Color::WHITE );
2544   // flush the queue and render once
2545   application.SendNotification();
2546   application.Render();
2547
2548   DALI_TEST_EQUALS( result1, 0u, TEST_LOCATION );  ///< constraint 1 should not apply now.
2549   DALI_TEST_EQUALS( result2, 2u, TEST_LOCATION );
2550
2551   // 3. Re-Apply Constraint1 and test...
2552   result1 = 0;
2553   result2 = 0;
2554   constraint1.Apply();
2555   // make color property dirty, which will trigger constraints to be reapplied.
2556   actor.SetColor( Color::WHITE );
2557   // flush the queue and render once
2558   application.SendNotification();
2559   application.Render();
2560
2561   DALI_TEST_EQUALS( result1, 1u, TEST_LOCATION );
2562   DALI_TEST_EQUALS( result2, 2u, TEST_LOCATION );
2563
2564   // 2. Remove Constraint2 and test...
2565   result1 = 0;
2566   result2 = 0;
2567   actor.RemoveConstraints(constraint2Tag);
2568   // make color property dirty, which will trigger constraints to be reapplied.
2569   actor.SetColor( Color::WHITE );
2570   // flush the queue and render once
2571   application.SendNotification();
2572   application.Render();
2573
2574   DALI_TEST_EQUALS( result1, 1u, TEST_LOCATION );
2575   DALI_TEST_EQUALS( result2, 0u, TEST_LOCATION ); ///< constraint 2 should not apply now.
2576
2577   // 2. Remove Constraint1 as well and test...
2578   result1 = 0;
2579   result2 = 0;
2580   actor.RemoveConstraints(constraint1Tag);
2581   // make color property dirty, which will trigger constraints to be reapplied.
2582   actor.SetColor( Color::WHITE );
2583   // flush the queue and render once
2584   application.SendNotification();
2585   application.Render();
2586
2587   DALI_TEST_EQUALS( result1, 0u, TEST_LOCATION ); ///< constraint 1 should not apply now.
2588   DALI_TEST_EQUALS( result2, 0u, TEST_LOCATION ); ///< constraint 2 should not apply now.
2589   END_TEST;
2590 }
2591
2592 int UtcDaliActorTouchedSignal(void)
2593 {
2594   TestApplication application;
2595
2596   ResetTouchCallbacks();
2597
2598   // get the root layer
2599   Actor actor = Stage::GetCurrent().GetRootLayer();
2600   DALI_TEST_CHECK( gTouchCallBackCalled == false );
2601
2602   application.SendNotification();
2603   application.Render();
2604
2605   // connect to its touch signal
2606   actor.TouchedSignal().Connect( TestCallback );
2607
2608   // simulate a touch event in the middle of the screen
2609   Vector2 touchPoint( Stage::GetCurrent().GetSize() * 0.5 );
2610   Dali::Integration::Point point;
2611   point.SetDeviceId( 1 );
2612   point.SetState( PointState::DOWN );
2613   point.SetScreenPosition( Vector2( touchPoint.x, touchPoint.y ) );
2614   Dali::Integration::TouchEvent touchEvent;
2615   touchEvent.AddPoint( point );
2616   application.ProcessEvent( touchEvent );
2617
2618   DALI_TEST_CHECK( gTouchCallBackCalled == true );
2619   END_TEST;
2620 }
2621
2622 int UtcDaliActorHoveredSignal(void)
2623 {
2624   TestApplication application;
2625
2626   gHoverCallBackCalled = false;
2627
2628   // get the root layer
2629   Actor actor = Stage::GetCurrent().GetRootLayer();
2630   DALI_TEST_CHECK( gHoverCallBackCalled == false );
2631
2632   application.SendNotification();
2633   application.Render();
2634
2635   // connect to its hover signal
2636   actor.HoveredSignal().Connect( TestCallback3 );
2637
2638   // simulate a hover event in the middle of the screen
2639   Vector2 touchPoint( Stage::GetCurrent().GetSize() * 0.5 );
2640   Dali::Integration::Point point;
2641   point.SetDeviceId( 1 );
2642   point.SetState( PointState::MOTION );
2643   point.SetScreenPosition( Vector2( touchPoint.x, touchPoint.y ) );
2644   Dali::Integration::HoverEvent hoverEvent;
2645   hoverEvent.AddPoint( point );
2646   application.ProcessEvent( hoverEvent );
2647
2648   DALI_TEST_CHECK( gHoverCallBackCalled == true );
2649   END_TEST;
2650 }
2651
2652 int UtcDaliActorOnOffStageSignal(void)
2653 {
2654   tet_infoline("Testing Dali::Actor::OnStageSignal() and OffStageSignal()");
2655
2656   TestApplication application;
2657
2658   // clean test data
2659   gOnStageCallBackCalled = gOffStageCallBackCalled = 0;
2660   gActorNamesOnOffStage.clear();
2661
2662   Actor parent = Actor::New();
2663   parent.SetName( "parent" );
2664   parent.OnStageSignal().Connect( OnStageCallback );
2665   parent.OffStageSignal().Connect( OffStageCallback );
2666   // sanity check
2667   DALI_TEST_CHECK( gOnStageCallBackCalled == 0 );
2668   DALI_TEST_CHECK( gOffStageCallBackCalled == 0 );
2669
2670   // add parent to stage
2671   Stage::GetCurrent().Add( parent );
2672   // onstage emitted, offstage not
2673   DALI_TEST_EQUALS(  gOnStageCallBackCalled, 1, TEST_LOCATION );
2674   DALI_TEST_EQUALS( gOffStageCallBackCalled, 0, TEST_LOCATION );
2675   DALI_TEST_EQUALS( "parent", gActorNamesOnOffStage[ 0 ], TEST_LOCATION );
2676
2677   // test adding a child, should get onstage emitted
2678   // clean test data
2679   gOnStageCallBackCalled = gOffStageCallBackCalled = 0;
2680   gActorNamesOnOffStage.clear();
2681
2682   Actor child = Actor::New();
2683   child.SetName( "child" );
2684   child.OnStageSignal().Connect( OnStageCallback );
2685   child.OffStageSignal().Connect( OffStageCallback );
2686   parent.Add( child ); // add child
2687   // onstage emitted, offstage not
2688   DALI_TEST_EQUALS(  gOnStageCallBackCalled, 1, TEST_LOCATION );
2689   DALI_TEST_EQUALS( gOffStageCallBackCalled, 0, TEST_LOCATION );
2690   DALI_TEST_EQUALS( "child", gActorNamesOnOffStage[ 0 ], TEST_LOCATION );
2691
2692   // test removing parent from stage
2693   // clean test data
2694   gOnStageCallBackCalled = gOffStageCallBackCalled = 0;
2695   gActorNamesOnOffStage.clear();
2696
2697   Stage::GetCurrent().Remove( parent );
2698   // onstage not emitted, offstage is
2699   DALI_TEST_EQUALS(  gOnStageCallBackCalled, 0, TEST_LOCATION );
2700   DALI_TEST_EQUALS( gOffStageCallBackCalled, 2, TEST_LOCATION );
2701   DALI_TEST_EQUALS( "child", gActorNamesOnOffStage[ 0 ], TEST_LOCATION );
2702   DALI_TEST_EQUALS( "parent", gActorNamesOnOffStage[ 1 ], TEST_LOCATION );
2703
2704   // test adding parent back to stage
2705   // clean test data
2706   gOnStageCallBackCalled = gOffStageCallBackCalled = 0;
2707   gActorNamesOnOffStage.clear();
2708
2709   Stage::GetCurrent().Add( parent );
2710   // onstage emitted, offstage not
2711   DALI_TEST_EQUALS(  gOnStageCallBackCalled, 2, TEST_LOCATION );
2712   DALI_TEST_EQUALS( gOffStageCallBackCalled, 0, TEST_LOCATION );
2713   DALI_TEST_EQUALS( "parent", gActorNamesOnOffStage[ 0 ], TEST_LOCATION );
2714   DALI_TEST_EQUALS( "child", gActorNamesOnOffStage[ 1 ], TEST_LOCATION );
2715
2716   // test removing child
2717   // clean test data
2718   gOnStageCallBackCalled = gOffStageCallBackCalled = 0;
2719   gActorNamesOnOffStage.clear();
2720
2721   parent.Remove( child );
2722   // onstage not emitted, offstage is
2723   DALI_TEST_EQUALS(  gOnStageCallBackCalled, 0, TEST_LOCATION );
2724   DALI_TEST_EQUALS( gOffStageCallBackCalled, 1, TEST_LOCATION );
2725   DALI_TEST_EQUALS( "child", gActorNamesOnOffStage[ 0 ], TEST_LOCATION );
2726
2727   // test removing parent
2728   // clean test data
2729   gOnStageCallBackCalled = gOffStageCallBackCalled = 0;
2730   gActorNamesOnOffStage.clear();
2731
2732   Stage::GetCurrent().Remove( parent );
2733   // onstage not emitted, offstage is
2734   DALI_TEST_EQUALS(  gOnStageCallBackCalled, 0, TEST_LOCATION );
2735   DALI_TEST_EQUALS( gOffStageCallBackCalled, 1, TEST_LOCATION );
2736   DALI_TEST_EQUALS( "parent", gActorNamesOnOffStage[ 0 ], TEST_LOCATION );
2737   END_TEST;
2738 }
2739
2740 int UtcDaliActorFindChildByName(void)
2741 {
2742   tet_infoline("Testing Dali::Actor::FindChildByName()");
2743   TestApplication application;
2744
2745   Actor parent = Actor::New();
2746   parent.SetName( "parent" );
2747   Actor first  = Actor::New();
2748   first .SetName( "first" );
2749   Actor second = Actor::New();
2750   second.SetName( "second" );
2751
2752   parent.Add(first);
2753   first.Add(second);
2754
2755   Actor found = parent.FindChildByName( "foo" );
2756   DALI_TEST_CHECK( !found );
2757
2758   found = parent.FindChildByName( "parent" );
2759   DALI_TEST_CHECK( found == parent );
2760
2761   found = parent.FindChildByName( "first" );
2762   DALI_TEST_CHECK( found == first );
2763
2764   found = parent.FindChildByName( "second" );
2765   DALI_TEST_CHECK( found == second );
2766   END_TEST;
2767 }
2768
2769 int UtcDaliActorFindChildById(void)
2770 {
2771   tet_infoline("Testing Dali::Actor::UtcDaliActorFindChildById()");
2772   TestApplication application;
2773
2774   Actor parent = Actor::New();
2775   Actor first  = Actor::New();
2776   Actor second = Actor::New();
2777
2778   parent.Add(first);
2779   first.Add(second);
2780
2781   Actor found = parent.FindChildById( 100000 );
2782   DALI_TEST_CHECK( !found );
2783
2784   found = parent.FindChildById( parent.GetId() );
2785   DALI_TEST_CHECK( found == parent );
2786
2787   found = parent.FindChildById( first.GetId() );
2788   DALI_TEST_CHECK( found == first );
2789
2790   found = parent.FindChildById( second.GetId() );
2791   DALI_TEST_CHECK( found == second );
2792   END_TEST;
2793 }
2794
2795 int UtcDaliActorHitTest(void)
2796 {
2797   struct HitTestData
2798   {
2799   public:
2800     HitTestData( const Vector3& scale, const Vector2& touchPoint, bool result )
2801     : mScale( scale ),
2802       mTouchPoint( touchPoint ),
2803       mResult( result )
2804     {}
2805
2806     Vector3 mScale;
2807     Vector2 mTouchPoint;
2808     bool mResult;
2809   };
2810
2811   TestApplication application;
2812   tet_infoline(" UtcDaliActorHitTest");
2813
2814   // Fill a vector with different hit tests.
2815   struct HitTestData* hitTestData[] = {
2816     //                    scale                     touch point           result
2817     new HitTestData( Vector3( 100.f, 100.f, 1.f ), Vector2( 289.f, 400.f ), true ),  // touch point close to the right edge (inside)
2818     new HitTestData( Vector3( 100.f, 100.f, 1.f ), Vector2( 291.f, 400.f ), false ), // touch point close to the right edge (outside)
2819     new HitTestData( Vector3( 110.f, 100.f, 1.f ), Vector2( 291.f, 400.f ), true ),  // same point as above with a wider scale. Should be inside.
2820     new HitTestData( Vector3( 100.f, 100.f, 1.f ), Vector2( 200.f, 451.f ), false ), // touch point close to the down edge (outside)
2821     new HitTestData( Vector3( 100.f, 110.f, 1.f ), Vector2( 200.f, 451.f ), true ),  // same point as above with a wider scale. Should be inside.
2822     NULL,
2823   };
2824
2825   // get the root layer
2826   Actor actor = Actor::New();
2827   actor.SetAnchorPoint( AnchorPoint::CENTER );
2828   actor.SetParentOrigin( ParentOrigin::CENTER );
2829
2830   Stage::GetCurrent().Add( actor );
2831
2832   ResetTouchCallbacks();
2833
2834   unsigned int index = 0;
2835   while( NULL != hitTestData[index] )
2836   {
2837     actor.SetSize( 1.f, 1.f );
2838     actor.SetScale( hitTestData[index]->mScale.x, hitTestData[index]->mScale.y, hitTestData[index]->mScale.z );
2839
2840     // flush the queue and render once
2841     application.SendNotification();
2842     application.Render();
2843
2844     DALI_TEST_CHECK( !gTouchCallBackCalled );
2845
2846     // connect to its touch signal
2847     actor.TouchedSignal().Connect(TestCallback);
2848
2849     Dali::Integration::Point point;
2850     point.SetState( PointState::DOWN );
2851     point.SetScreenPosition( Vector2( hitTestData[index]->mTouchPoint.x, hitTestData[index]->mTouchPoint.y ) );
2852     Dali::Integration::TouchEvent event;
2853     event.AddPoint( point );
2854
2855     // flush the queue and render once
2856     application.SendNotification();
2857     application.Render();
2858     application.ProcessEvent( event );
2859
2860     DALI_TEST_CHECK( gTouchCallBackCalled == hitTestData[index]->mResult );
2861
2862     if( gTouchCallBackCalled != hitTestData[index]->mResult )
2863       tet_printf("Test failed:\nScale %f %f %f\nTouchPoint %f, %f\nResult %d\n",
2864                  hitTestData[index]->mScale.x, hitTestData[index]->mScale.y, hitTestData[index]->mScale.z,
2865                  hitTestData[index]->mTouchPoint.x, hitTestData[index]->mTouchPoint.y,
2866                  hitTestData[index]->mResult );
2867
2868     ResetTouchCallbacks();
2869     ++index;
2870   }
2871   END_TEST;
2872 }
2873
2874 int UtcDaliActorSetDrawMode(void)
2875 {
2876   TestApplication app;
2877   tet_infoline(" UtcDaliActorSetDrawModeOverlay");
2878
2879   Actor a = Actor::New();
2880
2881   Stage::GetCurrent().Add(a);
2882   app.SendNotification();
2883   app.Render(0);
2884   app.SendNotification();
2885   app.Render(1);
2886
2887   DALI_TEST_CHECK( DrawMode::NORMAL == a.GetDrawMode() ); // Ensure overlay is off by default
2888
2889   a.SetDrawMode( DrawMode::OVERLAY_2D );
2890   app.SendNotification();
2891   app.Render(1);
2892
2893   DALI_TEST_CHECK( DrawMode::OVERLAY_2D == a.GetDrawMode() ); // Check Actor is overlay
2894
2895   a.SetDrawMode( DrawMode::NORMAL );
2896   app.SendNotification();
2897   app.Render(1);
2898
2899   DALI_TEST_CHECK( DrawMode::NORMAL == a.GetDrawMode() ); // Check Actor is normal
2900   END_TEST;
2901 }
2902
2903 int UtcDaliActorSetDrawModeOverlayRender(void)
2904 {
2905   TestApplication app;
2906   tet_infoline(" UtcDaliActorSetDrawModeOverlayRender");
2907
2908   app.SendNotification();
2909   app.Render(1);
2910
2911   std::vector<GLuint> ids;
2912   ids.push_back( 8 );   // first rendered actor
2913   ids.push_back( 9 );   // second rendered actor
2914   ids.push_back( 10 );  // third rendered actor
2915   app.GetGlAbstraction().SetNextTextureIds( ids );
2916
2917   BufferImage imageA = BufferImage::New(16, 16);
2918   BufferImage imageB = BufferImage::New(16, 16);
2919   BufferImage imageC = BufferImage::New(16, 16);
2920   Actor a = CreateRenderableActor( imageA );
2921   Actor b = CreateRenderableActor( imageB );
2922   Actor c = CreateRenderableActor( imageC );
2923
2924   app.SendNotification();
2925   app.Render(1);
2926
2927   //Textures are bound when first created. Clear bound textures vector
2928   app.GetGlAbstraction().ClearBoundTextures();
2929
2930   // Render a,b,c as regular non-overlays. so order will be:
2931   // a (8)
2932   // b (9)
2933   // c (10)
2934   Stage::GetCurrent().Add(a);
2935   Stage::GetCurrent().Add(b);
2936   Stage::GetCurrent().Add(c);
2937
2938   app.SendNotification();
2939   app.Render(1);
2940
2941   // Should be 3 textures changes.
2942   const std::vector<GLuint>& boundTextures = app.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
2943   typedef std::vector<GLuint>::size_type TextureSize;
2944   DALI_TEST_EQUALS( boundTextures.size(), static_cast<TextureSize>( 3 ), TEST_LOCATION );
2945   if( boundTextures.size() == 3 )
2946   {
2947     DALI_TEST_CHECK( boundTextures[0] == 8u );
2948     DALI_TEST_CHECK( boundTextures[1] == 9u );
2949     DALI_TEST_CHECK( boundTextures[2] == 10u );
2950   }
2951
2952   // Now texture ids have been set, we can monitor their render order.
2953   // render a as an overlay (last), so order will be:
2954   // b (9)
2955   // c (10)
2956   // a (8)
2957   a.SetDrawMode( DrawMode::OVERLAY_2D );
2958   app.GetGlAbstraction().ClearBoundTextures();
2959
2960   app.SendNotification();
2961   app.Render(1);
2962
2963   // Should be 3 texture changes.
2964   DALI_TEST_EQUALS( boundTextures.size(), static_cast<TextureSize>(3), TEST_LOCATION );
2965   if( boundTextures.size() == 3 )
2966   {
2967     DALI_TEST_CHECK( boundTextures[0] == 9u );
2968     DALI_TEST_CHECK( boundTextures[1] == 10u );
2969     DALI_TEST_CHECK( boundTextures[2] == 8u );
2970   }
2971   END_TEST;
2972 }
2973
2974 int UtcDaliActorGetCurrentWorldMatrix(void)
2975 {
2976   TestApplication app;
2977   tet_infoline(" UtcDaliActorGetCurrentWorldMatrix");
2978
2979   Actor parent = Actor::New();
2980   parent.SetParentOrigin(ParentOrigin::CENTER);
2981   parent.SetAnchorPoint(AnchorPoint::CENTER);
2982   Vector3 parentPosition( 10.0f, 20.0f, 30.0f);
2983   Radian rotationAngle(Degree(85.0f));
2984   Quaternion parentRotation(rotationAngle, Vector3::ZAXIS);
2985   Vector3 parentScale( 1.0f, 2.0f, 3.0f );
2986   parent.SetPosition( parentPosition );
2987   parent.SetOrientation( parentRotation );
2988   parent.SetScale( parentScale );
2989   Stage::GetCurrent().Add( parent );
2990
2991   Actor child = Actor::New();
2992   child.SetParentOrigin(ParentOrigin::CENTER);
2993   Vector3 childPosition( 0.0f, 0.0f, 100.0f );
2994   Radian childRotationAngle(Degree(23.0f));
2995   Quaternion childRotation( childRotationAngle, Vector3::YAXIS );
2996   Vector3 childScale( 2.0f, 2.0f, 2.0f );
2997   child.SetPosition( childPosition );
2998   child.SetOrientation( childRotation );
2999   child.SetScale( childScale );
3000   parent.Add( child );
3001
3002   app.SendNotification();
3003   app.Render(0);
3004   app.Render();
3005   app.SendNotification();
3006
3007   Matrix parentMatrix(false);
3008   parentMatrix.SetTransformComponents(parentScale, parentRotation, parentPosition);
3009
3010   Matrix childMatrix(false);
3011   childMatrix.SetTransformComponents( childScale, childRotation, childPosition );
3012
3013   //Child matrix should be the composition of child and parent
3014   Matrix childWorldMatrix(false);
3015   Matrix::Multiply( childWorldMatrix, childMatrix, parentMatrix);
3016
3017   DALI_TEST_EQUALS( parent.GetCurrentWorldMatrix(), parentMatrix, 0.001, TEST_LOCATION );
3018   DALI_TEST_EQUALS( child.GetCurrentWorldMatrix(), childWorldMatrix, 0.001, TEST_LOCATION );
3019   END_TEST;
3020 }
3021
3022
3023
3024 int UtcDaliActorConstrainedToWorldMatrix(void)
3025 {
3026   TestApplication app;
3027   tet_infoline(" UtcDaliActorConstrainedToWorldMatrix");
3028
3029   Actor parent = Actor::New();
3030   parent.SetParentOrigin(ParentOrigin::CENTER);
3031   parent.SetAnchorPoint(AnchorPoint::CENTER);
3032   Vector3 parentPosition( 10.0f, 20.0f, 30.0f);
3033   Radian rotationAngle(Degree(85.0f));
3034   Quaternion parentRotation(rotationAngle, Vector3::ZAXIS);
3035   Vector3 parentScale( 1.0f, 2.0f, 3.0f );
3036   parent.SetPosition( parentPosition );
3037   parent.SetOrientation( parentRotation );
3038   parent.SetScale( parentScale );
3039   Stage::GetCurrent().Add( parent );
3040
3041   Actor child = Actor::New();
3042   child.SetParentOrigin(ParentOrigin::CENTER);
3043   Constraint posConstraint = Constraint::New<Vector3>( child, Actor::Property::POSITION, PositionComponentConstraint() );
3044   posConstraint.AddSource( Source( parent, Actor::Property::WORLD_MATRIX ) );
3045   posConstraint.Apply();
3046
3047   Stage::GetCurrent().Add( child );
3048
3049   app.SendNotification();
3050   app.Render(0);
3051   app.Render();
3052   app.SendNotification();
3053
3054   Matrix parentMatrix(false);
3055   parentMatrix.SetTransformComponents(parentScale, parentRotation, parentPosition);
3056
3057   DALI_TEST_EQUALS( parent.GetCurrentWorldMatrix(), parentMatrix, 0.001, TEST_LOCATION );
3058   DALI_TEST_EQUALS( child.GetCurrentPosition(), parent.GetCurrentPosition(), 0.001, TEST_LOCATION );
3059   END_TEST;
3060 }
3061
3062 int UtcDaliActorConstrainedToOrientation(void)
3063 {
3064   TestApplication app;
3065   tet_infoline(" UtcDaliActorConstrainedToOrientation");
3066
3067   Actor parent = Actor::New();
3068   parent.SetParentOrigin(ParentOrigin::CENTER);
3069   parent.SetAnchorPoint(AnchorPoint::CENTER);
3070   Vector3 parentPosition( 10.0f, 20.0f, 30.0f);
3071   Radian rotationAngle(Degree(85.0f));
3072   Quaternion parentRotation(rotationAngle, Vector3::ZAXIS);
3073   Vector3 parentScale( 1.0f, 2.0f, 3.0f );
3074   parent.SetPosition( parentPosition );
3075   parent.SetOrientation( parentRotation );
3076   parent.SetScale( parentScale );
3077   Stage::GetCurrent().Add( parent );
3078
3079   Actor child = Actor::New();
3080   child.SetParentOrigin(ParentOrigin::CENTER);
3081   Constraint posConstraint = Constraint::New<Quaternion>( child, Actor::Property::ORIENTATION, OrientationComponentConstraint() );
3082   posConstraint.AddSource( Source( parent, Actor::Property::ORIENTATION ) );
3083   posConstraint.Apply();
3084
3085   Stage::GetCurrent().Add( child );
3086
3087   app.SendNotification();
3088   app.Render(0);
3089   app.Render();
3090   app.SendNotification();
3091
3092   DALI_TEST_EQUALS( child.GetCurrentOrientation(), parent.GetCurrentOrientation(), 0.001, TEST_LOCATION );
3093   END_TEST;
3094 }
3095
3096 int UtcDaliActorConstrainedToOpacity(void)
3097 {
3098   TestApplication app;
3099   tet_infoline(" UtcDaliActorConstrainedToOpacity");
3100
3101   Actor parent = Actor::New();
3102   parent.SetOpacity( 0.7f );
3103   Stage::GetCurrent().Add( parent );
3104
3105   Actor child = Actor::New();
3106   Constraint opacityConstraint = Constraint::New<float>( child, DevelActor::Property::OPACITY, EqualToConstraint() );
3107   opacityConstraint.AddSource( Source( parent, DevelActor::Property::OPACITY ) );
3108   opacityConstraint.Apply();
3109
3110   Stage::GetCurrent().Add( child );
3111
3112   app.SendNotification();
3113   app.Render(0);
3114   app.Render();
3115   app.SendNotification();
3116
3117   DALI_TEST_EQUALS( child.GetCurrentOpacity(), parent.GetCurrentOpacity(), 0.001f, TEST_LOCATION );
3118
3119   parent.SetOpacity( 0.3f );
3120
3121   app.SendNotification();
3122   app.Render(0);
3123   app.Render();
3124   app.SendNotification();
3125
3126   DALI_TEST_EQUALS( child.GetCurrentOpacity(), parent.GetCurrentOpacity(), 0.001f, TEST_LOCATION );
3127
3128   END_TEST;
3129 }
3130
3131 int UtcDaliActorUnparent(void)
3132 {
3133   TestApplication app;
3134   tet_infoline(" UtcDaliActorUnparent");
3135
3136   Actor parent = Actor::New();
3137   Stage::GetCurrent().Add( parent );
3138
3139   Actor child = Actor::New();
3140
3141   DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
3142   DALI_TEST_CHECK( !child.GetParent() );
3143
3144   // Test that calling Unparent with no parent is a NOOP
3145   child.Unparent();
3146
3147   DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
3148   DALI_TEST_CHECK( !child.GetParent() );
3149
3150   // Test that Unparent works
3151   parent.Add( child );
3152
3153   DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
3154   DALI_TEST_CHECK( parent == child.GetParent() );
3155
3156   child.Unparent();
3157
3158   DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
3159   DALI_TEST_CHECK( !child.GetParent() );
3160
3161   // Test that UnparentAndReset works
3162   parent.Add( child );
3163
3164   DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
3165   DALI_TEST_CHECK( parent == child.GetParent() );
3166
3167   UnparentAndReset( child );
3168
3169   DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
3170   DALI_TEST_CHECK( !child );
3171
3172   // Test that UnparentAndReset is a NOOP with empty handle
3173   UnparentAndReset( child );
3174
3175   DALI_TEST_CHECK( !child );
3176   END_TEST;
3177 }
3178
3179 int UtcDaliActorGetChildAt(void)
3180 {
3181   TestApplication app;
3182   tet_infoline(" UtcDaliActorGetChildAt");
3183
3184   Actor parent = Actor::New();
3185   Stage::GetCurrent().Add( parent );
3186
3187   Actor child0 = Actor::New();
3188   parent.Add( child0 );
3189
3190   Actor child1 = Actor::New();
3191   parent.Add( child1 );
3192
3193   Actor child2 = Actor::New();
3194   parent.Add( child2 );
3195
3196   DALI_TEST_EQUALS( parent.GetChildAt( 0 ), child0, TEST_LOCATION );
3197   DALI_TEST_EQUALS( parent.GetChildAt( 1 ), child1, TEST_LOCATION );
3198   DALI_TEST_EQUALS( parent.GetChildAt( 2 ), child2, TEST_LOCATION );
3199   END_TEST;
3200 }
3201
3202 int UtcDaliActorSetGetOverlay(void)
3203 {
3204   TestApplication app;
3205   tet_infoline(" UtcDaliActorSetGetOverlay");
3206
3207   Actor parent = Actor::New();
3208   parent.SetDrawMode(DrawMode::OVERLAY_2D );
3209   DALI_TEST_CHECK( parent.GetDrawMode() == DrawMode::OVERLAY_2D );
3210   END_TEST;
3211 }
3212
3213
3214 int UtcDaliActorCreateDestroy(void)
3215 {
3216   Actor* actor = new Actor;
3217   DALI_TEST_CHECK( actor );
3218   delete actor;
3219   END_TEST;
3220 }
3221
3222 namespace
3223 {
3224 struct PropertyStringIndex
3225 {
3226   const char * const name;
3227   const Property::Index index;
3228   const Property::Type type;
3229 };
3230
3231 const PropertyStringIndex PROPERTY_TABLE[] =
3232 {
3233   { "parentOrigin",             Actor::Property::PARENT_ORIGIN,            Property::VECTOR3     },
3234   { "parentOriginX",            Actor::Property::PARENT_ORIGIN_X,          Property::FLOAT       },
3235   { "parentOriginY",            Actor::Property::PARENT_ORIGIN_Y,          Property::FLOAT       },
3236   { "parentOriginZ",            Actor::Property::PARENT_ORIGIN_Z,          Property::FLOAT       },
3237   { "anchorPoint",              Actor::Property::ANCHOR_POINT,             Property::VECTOR3     },
3238   { "anchorPointX",             Actor::Property::ANCHOR_POINT_X,           Property::FLOAT       },
3239   { "anchorPointY",             Actor::Property::ANCHOR_POINT_Y,           Property::FLOAT       },
3240   { "anchorPointZ",             Actor::Property::ANCHOR_POINT_Z,           Property::FLOAT       },
3241   { "size",                     Actor::Property::SIZE,                     Property::VECTOR3     },
3242   { "sizeWidth",                Actor::Property::SIZE_WIDTH,               Property::FLOAT       },
3243   { "sizeHeight",               Actor::Property::SIZE_HEIGHT,              Property::FLOAT       },
3244   { "sizeDepth",                Actor::Property::SIZE_DEPTH,               Property::FLOAT       },
3245   { "position",                 Actor::Property::POSITION,                 Property::VECTOR3     },
3246   { "positionX",                Actor::Property::POSITION_X,               Property::FLOAT       },
3247   { "positionY",                Actor::Property::POSITION_Y,               Property::FLOAT       },
3248   { "positionZ",                Actor::Property::POSITION_Z,               Property::FLOAT       },
3249   { "worldPosition",            Actor::Property::WORLD_POSITION,           Property::VECTOR3     },
3250   { "worldPositionX",           Actor::Property::WORLD_POSITION_X,         Property::FLOAT       },
3251   { "worldPositionY",           Actor::Property::WORLD_POSITION_Y,         Property::FLOAT       },
3252   { "worldPositionZ",           Actor::Property::WORLD_POSITION_Z,         Property::FLOAT       },
3253   { "orientation",              Actor::Property::ORIENTATION,              Property::ROTATION    },
3254   { "worldOrientation",         Actor::Property::WORLD_ORIENTATION,        Property::ROTATION    },
3255   { "scale",                    Actor::Property::SCALE,                    Property::VECTOR3     },
3256   { "scaleX",                   Actor::Property::SCALE_X,                  Property::FLOAT       },
3257   { "scaleY",                   Actor::Property::SCALE_Y,                  Property::FLOAT       },
3258   { "scaleZ",                   Actor::Property::SCALE_Z,                  Property::FLOAT       },
3259   { "worldScale",               Actor::Property::WORLD_SCALE,              Property::VECTOR3     },
3260   { "visible",                  Actor::Property::VISIBLE,                  Property::BOOLEAN     },
3261   { "color",                    Actor::Property::COLOR,                    Property::VECTOR4     },
3262   { "colorRed",                 Actor::Property::COLOR_RED,                Property::FLOAT       },
3263   { "colorGreen",               Actor::Property::COLOR_GREEN,              Property::FLOAT       },
3264   { "colorBlue",                Actor::Property::COLOR_BLUE,               Property::FLOAT       },
3265   { "colorAlpha",               Actor::Property::COLOR_ALPHA,              Property::FLOAT       },
3266   { "worldColor",               Actor::Property::WORLD_COLOR,              Property::VECTOR4     },
3267   { "worldMatrix",              Actor::Property::WORLD_MATRIX,             Property::MATRIX      },
3268   { "name",                     Actor::Property::NAME,                     Property::STRING      },
3269   { "sensitive",                Actor::Property::SENSITIVE,                Property::BOOLEAN     },
3270   { "leaveRequired",            Actor::Property::LEAVE_REQUIRED,           Property::BOOLEAN     },
3271   { "inheritOrientation",       Actor::Property::INHERIT_ORIENTATION,      Property::BOOLEAN     },
3272   { "inheritScale",             Actor::Property::INHERIT_SCALE,            Property::BOOLEAN     },
3273   { "colorMode",                Actor::Property::COLOR_MODE,               Property::STRING      },
3274   { "drawMode",                 Actor::Property::DRAW_MODE,                Property::STRING      },
3275   { "sizeModeFactor",           Actor::Property::SIZE_MODE_FACTOR,         Property::VECTOR3     },
3276   { "widthResizePolicy",        Actor::Property::WIDTH_RESIZE_POLICY,      Property::STRING      },
3277   { "heightResizePolicy",       Actor::Property::HEIGHT_RESIZE_POLICY,     Property::STRING      },
3278   { "sizeScalePolicy",          Actor::Property::SIZE_SCALE_POLICY,        Property::STRING      },
3279   { "widthForHeight",           Actor::Property::WIDTH_FOR_HEIGHT,         Property::BOOLEAN     },
3280   { "heightForWidth",           Actor::Property::HEIGHT_FOR_WIDTH,         Property::BOOLEAN     },
3281   { "padding",                  Actor::Property::PADDING,                  Property::VECTOR4     },
3282   { "minimumSize",              Actor::Property::MINIMUM_SIZE,             Property::VECTOR2     },
3283   { "maximumSize",              Actor::Property::MAXIMUM_SIZE,             Property::VECTOR2     },
3284   { "inheritPosition",          Actor::Property::INHERIT_POSITION,         Property::BOOLEAN     },
3285   { "clippingMode",             Actor::Property::CLIPPING_MODE,            Property::STRING      },
3286   { "opacity",                  DevelActor::Property::OPACITY,             Property::FLOAT       },
3287   { "updateSizeHint",           DevelActor::Property::UPDATE_SIZE_HINT,    Property::VECTOR2     },
3288 };
3289 const unsigned int PROPERTY_TABLE_COUNT = sizeof( PROPERTY_TABLE ) / sizeof( PROPERTY_TABLE[0] );
3290 } // unnamed namespace
3291
3292 int UtcDaliActorProperties(void)
3293 {
3294   TestApplication app;
3295
3296   Actor actor = Actor::New();
3297
3298   for ( unsigned int i = 0; i < PROPERTY_TABLE_COUNT; ++i )
3299   {
3300     tet_printf( "Checking %s == %d\n", PROPERTY_TABLE[i].name, PROPERTY_TABLE[i].index );
3301     DALI_TEST_EQUALS( actor.GetPropertyName( PROPERTY_TABLE[i].index ), PROPERTY_TABLE[i].name, TEST_LOCATION );
3302     DALI_TEST_EQUALS( actor.GetPropertyIndex( PROPERTY_TABLE[i].name ), PROPERTY_TABLE[i].index, TEST_LOCATION );
3303     DALI_TEST_EQUALS( actor.GetPropertyType( PROPERTY_TABLE[i].index ), PROPERTY_TABLE[i].type, TEST_LOCATION );
3304   }
3305   END_TEST;
3306 }
3307
3308 int UtcDaliRelayoutProperties_ResizePolicies(void)
3309 {
3310   TestApplication app;
3311
3312   Actor actor = Actor::New();
3313
3314   // Defaults
3315   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_RESIZE_POLICY ).Get< std::string >(), "USE_NATURAL_SIZE", TEST_LOCATION );
3316   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::HEIGHT_RESIZE_POLICY ).Get< std::string >(), "USE_NATURAL_SIZE", TEST_LOCATION );
3317
3318   // Set resize policy for all dimensions
3319   actor.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
3320   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i)
3321   {
3322     DALI_TEST_EQUALS( actor.GetResizePolicy( static_cast< Dimension::Type >( 1 << i ) ), ResizePolicy::USE_NATURAL_SIZE, TEST_LOCATION );
3323   }
3324
3325   // Set individual dimensions
3326   const char* const widthPolicy = "FILL_TO_PARENT";
3327   const char* const heightPolicy = "FIXED";
3328
3329   actor.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, widthPolicy );
3330   actor.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, heightPolicy );
3331
3332   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_RESIZE_POLICY ).Get< std::string >(), widthPolicy, TEST_LOCATION );
3333   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::HEIGHT_RESIZE_POLICY ).Get< std::string >(), heightPolicy, TEST_LOCATION );
3334
3335   // Set individual dimensions using enums
3336   ResizePolicy::Type widthPolicyEnum = ResizePolicy::USE_ASSIGNED_SIZE;
3337   ResizePolicy::Type heightPolicyEnum = ResizePolicy::SIZE_RELATIVE_TO_PARENT;
3338
3339   actor.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, widthPolicyEnum );
3340   actor.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, heightPolicyEnum );
3341
3342   DALI_TEST_EQUALS( static_cast< int >( actor.GetResizePolicy( Dimension::WIDTH ) ), static_cast< int >( widthPolicyEnum ), TEST_LOCATION );
3343   DALI_TEST_EQUALS( static_cast< int >( actor.GetResizePolicy( Dimension::HEIGHT ) ), static_cast< int >( heightPolicyEnum ), TEST_LOCATION );
3344
3345   END_TEST;
3346 }
3347
3348 int UtcDaliRelayoutProperties_SizeScalePolicy(void)
3349 {
3350   TestApplication app;
3351
3352   Actor actor = Actor::New();
3353
3354   // Defaults
3355   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_SCALE_POLICY ).Get< std::string >(), "USE_SIZE_SET", TEST_LOCATION );
3356   DALI_TEST_EQUALS( actor.GetSizeScalePolicy(), SizeScalePolicy::USE_SIZE_SET, TEST_LOCATION );
3357
3358   SizeScalePolicy::Type policy = SizeScalePolicy::FILL_WITH_ASPECT_RATIO;
3359   actor.SetSizeScalePolicy( policy );
3360   DALI_TEST_EQUALS( actor.GetSizeScalePolicy(), policy, TEST_LOCATION );
3361
3362   // Set
3363   const char* const policy1 = "FIT_WITH_ASPECT_RATIO";
3364   const char* const policy2 = "FILL_WITH_ASPECT_RATIO";
3365
3366   actor.SetProperty( Actor::Property::SIZE_SCALE_POLICY, policy1 );
3367   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_SCALE_POLICY ).Get< std::string >(), policy1, TEST_LOCATION );
3368
3369   actor.SetProperty( Actor::Property::SIZE_SCALE_POLICY, policy2 );
3370   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_SCALE_POLICY ).Get< std::string >(), policy2, TEST_LOCATION );
3371
3372   END_TEST;
3373 }
3374
3375 int UtcDaliRelayoutProperties_SizeModeFactor(void)
3376 {
3377   TestApplication app;
3378
3379   Actor actor = Actor::New();
3380
3381   // Defaults
3382   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_MODE_FACTOR ).Get< Vector3 >(), Vector3( 1.0f, 1.0f, 1.0f ), TEST_LOCATION );
3383   DALI_TEST_EQUALS( actor.GetSizeModeFactor(), Vector3( 1.0f, 1.0f, 1.0f ), TEST_LOCATION );
3384
3385   Vector3 sizeMode( 1.0f, 2.0f, 3.0f );
3386   actor.SetSizeModeFactor( sizeMode );
3387   DALI_TEST_EQUALS( actor.GetSizeModeFactor(), sizeMode, TEST_LOCATION );
3388
3389   // Set
3390   Vector3 sizeMode1( 2.0f, 3.0f, 4.0f );
3391
3392   actor.SetProperty( Actor::Property::SIZE_MODE_FACTOR, sizeMode1 );
3393   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_MODE_FACTOR ).Get< Vector3 >(), sizeMode1, TEST_LOCATION );
3394
3395   END_TEST;
3396 }
3397
3398 int UtcDaliRelayoutProperties_DimensionDependency(void)
3399 {
3400   TestApplication app;
3401
3402   Actor actor = Actor::New();
3403
3404   // Defaults
3405   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_FOR_HEIGHT ).Get< bool >(), false, TEST_LOCATION );
3406   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::HEIGHT_FOR_WIDTH ).Get< bool >(), false, TEST_LOCATION );
3407
3408   // Set
3409   actor.SetProperty( Actor::Property::WIDTH_FOR_HEIGHT, true );
3410   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_FOR_HEIGHT ).Get< bool >(), true, TEST_LOCATION );
3411
3412   actor.SetProperty( Actor::Property::HEIGHT_FOR_WIDTH, true );
3413   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::HEIGHT_FOR_WIDTH ).Get< bool >(), true, TEST_LOCATION );
3414
3415   // Test setting another resize policy
3416   actor.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FIXED" );
3417   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_FOR_HEIGHT ).Get< bool >(), false, TEST_LOCATION );
3418
3419   END_TEST;
3420 }
3421
3422 int UtcDaliRelayoutProperties_Padding(void)
3423 {
3424   TestApplication app;
3425
3426   Actor actor = Actor::New();
3427
3428   // Data
3429   Vector4 padding( 1.0f, 2.0f, 3.0f, 4.0f );
3430
3431   // PADDING
3432   actor.SetProperty( Actor::Property::PADDING, padding );
3433   Vector4 paddingResult = actor.GetProperty( Actor::Property::PADDING ).Get< Vector4 >();
3434
3435   DALI_TEST_EQUALS( paddingResult, padding, Math::MACHINE_EPSILON_0, TEST_LOCATION );
3436
3437   END_TEST;
3438 }
3439
3440 int UtcDaliRelayoutProperties_MinimumMaximumSize(void)
3441 {
3442   TestApplication app;
3443
3444   Actor actor = Actor::New();
3445
3446   // Data
3447   Vector2 minSize( 1.0f, 2.0f );
3448
3449   actor.SetProperty( Actor::Property::MINIMUM_SIZE, minSize );
3450   Vector2 resultMin = actor.GetProperty( Actor::Property::MINIMUM_SIZE ).Get< Vector2 >();
3451
3452   DALI_TEST_EQUALS( resultMin, minSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
3453
3454   Vector2 maxSize( 3.0f, 4.0f );
3455
3456   actor.SetProperty( Actor::Property::MAXIMUM_SIZE, maxSize );
3457   Vector2 resultMax = actor.GetProperty( Actor::Property::MAXIMUM_SIZE ).Get< Vector2 >();
3458
3459   DALI_TEST_EQUALS( resultMax, maxSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
3460
3461   END_TEST;
3462 }
3463
3464 int UtcDaliActorGetHeightForWidth(void)
3465 {
3466   TestApplication app;
3467
3468   Actor actor = Actor::New();
3469
3470   DALI_TEST_EQUALS( actor.GetHeightForWidth( 1.0f ), 1.0f, TEST_LOCATION );
3471
3472   END_TEST;
3473 }
3474
3475 int UtcDaliActorGetWidthForHeight(void)
3476 {
3477   TestApplication app;
3478
3479   Actor actor = Actor::New();
3480
3481   DALI_TEST_EQUALS( actor.GetWidthForHeight( 1.0f ), 1.0f, TEST_LOCATION );
3482
3483   END_TEST;
3484 }
3485
3486 int UtcDaliActorGetRelayoutSize(void)
3487 {
3488   TestApplication app;
3489
3490   Actor actor = Actor::New();
3491
3492   // Add actor to stage
3493   Stage::GetCurrent().Add( actor );
3494
3495   DALI_TEST_EQUALS( actor.GetRelayoutSize( Dimension::WIDTH ), 0.0f, TEST_LOCATION );
3496
3497   actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::WIDTH );
3498   actor.SetSize( Vector2( 1.0f, 0.0f ) );
3499
3500   // Flush the queue and render once
3501   app.SendNotification();
3502   app.Render();
3503
3504   DALI_TEST_EQUALS( actor.GetRelayoutSize( Dimension::WIDTH ), 1.0f, TEST_LOCATION );
3505
3506   END_TEST;
3507 }
3508
3509 int UtcDaliActorSetPadding(void)
3510 {
3511   TestApplication app;
3512
3513   Actor actor = Actor::New();
3514
3515   Padding padding;
3516   actor.GetPadding( padding );
3517
3518   DALI_TEST_EQUALS( padding.left, 0.0f, TEST_LOCATION );
3519   DALI_TEST_EQUALS( padding.right, 0.0f, TEST_LOCATION );
3520   DALI_TEST_EQUALS( padding.bottom, 0.0f, TEST_LOCATION );
3521   DALI_TEST_EQUALS( padding.top, 0.0f, TEST_LOCATION );
3522
3523   Padding padding2( 1.0f, 2.0f, 3.0f, 4.0f );
3524   actor.SetPadding( padding2 );
3525
3526   actor.GetPadding( padding );
3527
3528   DALI_TEST_EQUALS( padding.left, padding2.left, TEST_LOCATION );
3529   DALI_TEST_EQUALS( padding.right, padding2.right, TEST_LOCATION );
3530   DALI_TEST_EQUALS( padding.bottom, padding2.bottom, TEST_LOCATION );
3531   DALI_TEST_EQUALS( padding.top, padding2.top, TEST_LOCATION );
3532
3533   END_TEST;
3534 }
3535
3536 int UtcDaliActorSetMinimumSize(void)
3537 {
3538   TestApplication app;
3539
3540   Actor actor = Actor::New();
3541
3542   Vector2 size = actor.GetMinimumSize();
3543
3544   DALI_TEST_EQUALS( size.width, 0.0f, TEST_LOCATION );
3545   DALI_TEST_EQUALS( size.height, 0.0f, TEST_LOCATION );
3546
3547   Vector2 size2( 1.0f, 2.0f );
3548   actor.SetMinimumSize( size2 );
3549
3550   size = actor.GetMinimumSize();
3551
3552   DALI_TEST_EQUALS( size.width, size2.width, TEST_LOCATION );
3553   DALI_TEST_EQUALS( size.height, size2.height, TEST_LOCATION );
3554
3555   END_TEST;
3556 }
3557
3558 int UtcDaliActorSetMaximumSize(void)
3559 {
3560   TestApplication app;
3561
3562   Actor actor = Actor::New();
3563
3564   Vector2 size = actor.GetMaximumSize();
3565
3566   DALI_TEST_EQUALS( size.width, FLT_MAX, TEST_LOCATION );
3567   DALI_TEST_EQUALS( size.height, FLT_MAX, TEST_LOCATION );
3568
3569   Vector2 size2( 1.0f, 2.0f );
3570   actor.SetMaximumSize( size2 );
3571
3572   size = actor.GetMaximumSize();
3573
3574   DALI_TEST_EQUALS( size.width, size2.width, TEST_LOCATION );
3575   DALI_TEST_EQUALS( size.height, size2.height, TEST_LOCATION );
3576
3577   END_TEST;
3578 }
3579
3580 int UtcDaliActorOnRelayoutSignal(void)
3581 {
3582   tet_infoline("Testing Dali::Actor::OnRelayoutSignal()");
3583
3584   TestApplication application;
3585
3586   // Clean test data
3587   gOnRelayoutCallBackCalled = false;
3588   gActorNamesRelayout.clear();
3589
3590   Actor actor = Actor::New();
3591   actor.SetName( "actor" );
3592   actor.OnRelayoutSignal().Connect( OnRelayoutCallback );
3593
3594   // Sanity check
3595   DALI_TEST_CHECK( ! gOnRelayoutCallBackCalled );
3596
3597   // Add actor to stage
3598   Stage::GetCurrent().Add( actor );
3599
3600   actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
3601   actor.SetSize( Vector2( 1.0f, 2.0 ) );
3602
3603   // Flush the queue and render once
3604   application.SendNotification();
3605   application.Render();
3606
3607   // OnRelayout emitted
3608   DALI_TEST_EQUALS(  gOnRelayoutCallBackCalled, true, TEST_LOCATION );
3609   DALI_TEST_EQUALS( "actor", gActorNamesRelayout[ 0 ], TEST_LOCATION );
3610
3611   END_TEST;
3612 }
3613
3614 int UtcDaliActorGetHierachyDepth(void)
3615 {
3616   TestApplication application;
3617   tet_infoline("Testing Dali::Actor::GetHierarchyDepth()");
3618
3619
3620   /* Build tree of actors:
3621    *
3622    *                      Depth
3623    *
3624    *       A (parent)       1
3625    *      / \
3626    *     B   C              2`
3627    *    / \   \
3628    *   D   E   F            3
3629    *
3630    * GetHierarchyDepth should return 1 for A, 2 for B and C, and 3 for D, E and F.
3631    */
3632   Stage stage( Stage::GetCurrent() );
3633
3634   Actor actorA = Actor::New();
3635   Actor actorB = Actor::New();
3636   Actor actorC = Actor::New();
3637   Actor actorD = Actor::New();
3638   Actor actorE = Actor::New();
3639   Actor actorF = Actor::New();
3640
3641   //Test that root actor has depth equal 0
3642   DALI_TEST_EQUALS( 0, stage.GetRootLayer().GetHierarchyDepth(), TEST_LOCATION );
3643
3644   //Test actors return depth -1 when not connected to the tree
3645   DALI_TEST_EQUALS( -1, actorA.GetHierarchyDepth(), TEST_LOCATION );
3646   DALI_TEST_EQUALS( -1, actorB.GetHierarchyDepth(), TEST_LOCATION );
3647   DALI_TEST_EQUALS( -1, actorC.GetHierarchyDepth(), TEST_LOCATION );
3648   DALI_TEST_EQUALS( -1, actorD.GetHierarchyDepth(), TEST_LOCATION );
3649   DALI_TEST_EQUALS( -1, actorE.GetHierarchyDepth(), TEST_LOCATION );
3650   DALI_TEST_EQUALS( -1, actorF.GetHierarchyDepth(), TEST_LOCATION );
3651
3652   //Create the hierarchy
3653   stage.Add( actorA );
3654   actorA.Add( actorB );
3655   actorA.Add( actorC );
3656   actorB.Add( actorD );
3657   actorB.Add( actorE );
3658   actorC.Add( actorF );
3659
3660   //Test actors return correct depth
3661   DALI_TEST_EQUALS( 1, actorA.GetHierarchyDepth(), TEST_LOCATION );
3662   DALI_TEST_EQUALS( 2, actorB.GetHierarchyDepth(), TEST_LOCATION );
3663   DALI_TEST_EQUALS( 2, actorC.GetHierarchyDepth(), TEST_LOCATION );
3664   DALI_TEST_EQUALS( 3, actorD.GetHierarchyDepth(), TEST_LOCATION );
3665   DALI_TEST_EQUALS( 3, actorE.GetHierarchyDepth(), TEST_LOCATION );
3666   DALI_TEST_EQUALS( 3, actorF.GetHierarchyDepth(), TEST_LOCATION );
3667
3668   //Removing actorB from the hierarchy. actorB, actorD and actorE should now have depth equal -1
3669   actorA.Remove( actorB );
3670
3671   DALI_TEST_EQUALS( -1, actorB.GetHierarchyDepth(), TEST_LOCATION );
3672   DALI_TEST_EQUALS( -1, actorD.GetHierarchyDepth(), TEST_LOCATION );
3673   DALI_TEST_EQUALS( -1, actorE.GetHierarchyDepth(), TEST_LOCATION );
3674
3675   //Removing actorA from the stage. All actors should have depth equal -1
3676   stage.Remove( actorA );
3677
3678   DALI_TEST_EQUALS( -1, actorA.GetHierarchyDepth(), TEST_LOCATION );
3679   DALI_TEST_EQUALS( -1, actorB.GetHierarchyDepth(), TEST_LOCATION );
3680   DALI_TEST_EQUALS( -1, actorC.GetHierarchyDepth(), TEST_LOCATION );
3681   DALI_TEST_EQUALS( -1, actorD.GetHierarchyDepth(), TEST_LOCATION );
3682   DALI_TEST_EQUALS( -1, actorE.GetHierarchyDepth(), TEST_LOCATION );
3683   DALI_TEST_EQUALS( -1, actorF.GetHierarchyDepth(), TEST_LOCATION );
3684
3685   END_TEST;
3686 }
3687
3688 int UtcDaliActorAnchorPointPropertyAsString(void)
3689 {
3690   TestApplication application;
3691
3692   Actor actor = Actor::New();
3693
3694   actor.SetProperty( Actor::Property::ANCHOR_POINT, "TOP_LEFT" );
3695   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::TOP_LEFT, TEST_LOCATION );
3696
3697   actor.SetProperty( Actor::Property::ANCHOR_POINT, "TOP_CENTER" );
3698   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::TOP_CENTER, TEST_LOCATION );
3699
3700   actor.SetProperty( Actor::Property::ANCHOR_POINT, "TOP_RIGHT" );
3701   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
3702
3703   actor.SetProperty( Actor::Property::ANCHOR_POINT, "CENTER_LEFT" );
3704   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::CENTER_LEFT, TEST_LOCATION );
3705
3706   actor.SetProperty( Actor::Property::ANCHOR_POINT, "CENTER" );
3707   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::CENTER, TEST_LOCATION );
3708
3709   actor.SetProperty( Actor::Property::ANCHOR_POINT, "CENTER_RIGHT" );
3710   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::CENTER_RIGHT, TEST_LOCATION );
3711
3712   actor.SetProperty( Actor::Property::ANCHOR_POINT, "BOTTOM_LEFT" );
3713   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::BOTTOM_LEFT, TEST_LOCATION );
3714
3715   actor.SetProperty( Actor::Property::ANCHOR_POINT, "BOTTOM_CENTER" );
3716   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::BOTTOM_CENTER, TEST_LOCATION );
3717
3718   actor.SetProperty( Actor::Property::ANCHOR_POINT, "BOTTOM_RIGHT" );
3719   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
3720
3721   // Invalid should not change anything
3722   actor.SetProperty( Actor::Property::ANCHOR_POINT, "INVALID_ARG" );
3723   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
3724
3725   END_TEST;
3726 }
3727
3728 int UtcDaliActorParentOriginPropertyAsString(void)
3729 {
3730   TestApplication application;
3731
3732   Actor actor = Actor::New();
3733
3734   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "TOP_LEFT" );
3735   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::TOP_LEFT, TEST_LOCATION );
3736
3737   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "TOP_CENTER" );
3738   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::TOP_CENTER, TEST_LOCATION );
3739
3740   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "TOP_RIGHT" );
3741   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
3742
3743   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "CENTER_LEFT" );
3744   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::CENTER_LEFT, TEST_LOCATION );
3745
3746   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "CENTER" );
3747   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::CENTER, TEST_LOCATION );
3748
3749   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "CENTER_RIGHT" );
3750   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::CENTER_RIGHT, TEST_LOCATION );
3751
3752   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "BOTTOM_LEFT" );
3753   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::BOTTOM_LEFT, TEST_LOCATION );
3754
3755   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "BOTTOM_CENTER" );
3756   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::BOTTOM_CENTER, TEST_LOCATION );
3757
3758   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "BOTTOM_RIGHT" );
3759   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
3760
3761   // Invalid should not change anything
3762   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "INVALID_ARG" );
3763   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
3764
3765   END_TEST;
3766 }
3767
3768 int UtcDaliActorColorModePropertyAsString(void)
3769 {
3770   TestApplication application;
3771
3772   Actor actor = Actor::New();
3773
3774   actor.SetProperty( Actor::Property::COLOR_MODE, "USE_OWN_COLOR" );
3775   DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_COLOR, TEST_LOCATION );
3776
3777   actor.SetProperty( Actor::Property::COLOR_MODE, "USE_PARENT_COLOR" );
3778   DALI_TEST_EQUALS( actor.GetColorMode(), USE_PARENT_COLOR, TEST_LOCATION );
3779
3780   actor.SetProperty( Actor::Property::COLOR_MODE, "USE_OWN_MULTIPLY_PARENT_COLOR" );
3781   DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_COLOR, TEST_LOCATION );
3782
3783   actor.SetProperty( Actor::Property::COLOR_MODE, "USE_OWN_MULTIPLY_PARENT_ALPHA" );
3784   DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION );
3785
3786   // Invalid should not change anything
3787   actor.SetProperty( Actor::Property::COLOR_MODE, "INVALID_ARG" );
3788   DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION );
3789
3790   END_TEST;
3791 }
3792
3793 int UtcDaliActorDrawModePropertyAsString(void)
3794 {
3795   TestApplication application;
3796
3797   Actor actor = Actor::New();
3798
3799   actor.SetProperty( Actor::Property::DRAW_MODE, "NORMAL" );
3800   DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::NORMAL, TEST_LOCATION );
3801
3802   actor.SetProperty( Actor::Property::DRAW_MODE, "OVERLAY_2D" );
3803   DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::OVERLAY_2D, TEST_LOCATION );
3804
3805   // Invalid should not change anything
3806   actor.SetProperty( Actor::Property::DRAW_MODE, "INVALID_ARG" );
3807   DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::OVERLAY_2D, TEST_LOCATION );
3808
3809   END_TEST;
3810 }
3811
3812 int UtcDaliActorColorModePropertyAsEnum(void)
3813 {
3814   TestApplication application;
3815
3816   Actor actor = Actor::New();
3817
3818   actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_COLOR );
3819   DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_COLOR, TEST_LOCATION );
3820
3821   actor.SetProperty( Actor::Property::COLOR_MODE, USE_PARENT_COLOR );
3822   DALI_TEST_EQUALS( actor.GetColorMode(), USE_PARENT_COLOR, TEST_LOCATION );
3823
3824   actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_COLOR );
3825   DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_COLOR, TEST_LOCATION );
3826
3827   actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_ALPHA );
3828   DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION );
3829
3830   END_TEST;
3831 }
3832
3833 int UtcDaliActorDrawModePropertyAsEnum(void)
3834 {
3835   TestApplication application;
3836
3837   Actor actor = Actor::New();
3838
3839   actor.SetProperty( Actor::Property::DRAW_MODE, DrawMode::NORMAL );
3840   DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::NORMAL, TEST_LOCATION );
3841
3842   actor.SetProperty( Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D );
3843   DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::OVERLAY_2D, TEST_LOCATION );
3844
3845   END_TEST;
3846 }
3847
3848 int UtcDaliActorAddRendererP(void)
3849 {
3850   tet_infoline("Testing Actor::AddRenderer");
3851   TestApplication application;
3852
3853   Actor actor = Actor::New();
3854
3855   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
3856
3857   Geometry geometry = CreateQuadGeometry();
3858   Shader shader = CreateShader();
3859   Renderer renderer = Renderer::New(geometry, shader);
3860
3861   actor.AddRenderer( renderer );
3862   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
3863   DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION );
3864
3865   END_TEST;
3866 }
3867
3868 int UtcDaliActorAddRendererN(void)
3869 {
3870   tet_infoline("Testing Actor::AddRenderer");
3871   TestApplication application;
3872
3873   Actor actor = Actor::New();
3874   Renderer renderer;
3875
3876   // try illegal Add
3877   try
3878   {
3879     actor.AddRenderer( renderer );
3880     tet_printf("Assertion test failed - no Exception\n" );
3881     tet_result(TET_FAIL);
3882   }
3883   catch(Dali::DaliException& e)
3884   {
3885     DALI_TEST_PRINT_ASSERT( e );
3886     DALI_TEST_ASSERT(e, "Renderer handle is empty", TEST_LOCATION);
3887     DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
3888   }
3889   catch(...)
3890   {
3891     tet_printf("Assertion test failed - wrong Exception\n" );
3892     tet_result(TET_FAIL);
3893   }
3894
3895   END_TEST;
3896 }
3897
3898 int UtcDaliActorAddRendererOnStage(void)
3899 {
3900   tet_infoline("Testing Actor::AddRenderer");
3901   TestApplication application;
3902
3903   Actor actor = Actor::New();
3904   Stage::GetCurrent().Add(actor);
3905
3906   application.SendNotification();
3907   application.Render(0);
3908
3909   Geometry geometry = CreateQuadGeometry();
3910   Shader shader = CreateShader();
3911   Renderer renderer = Renderer::New(geometry, shader);
3912
3913   application.SendNotification();
3914   application.Render(0);
3915
3916   try
3917   {
3918     actor.AddRenderer( renderer );
3919     tet_result(TET_PASS);
3920   }
3921   catch(...)
3922   {
3923     tet_result(TET_FAIL);
3924   }
3925
3926   END_TEST;
3927 }
3928
3929 int UtcDaliActorRemoveRendererP1(void)
3930 {
3931   tet_infoline("Testing Actor::RemoveRenderer");
3932   TestApplication application;
3933
3934   Actor actor = Actor::New();
3935
3936   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
3937
3938   {
3939     Geometry geometry = CreateQuadGeometry();
3940     Shader shader = CreateShader();
3941     Renderer renderer = Renderer::New(geometry, shader);
3942
3943     actor.AddRenderer( renderer );
3944     DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
3945     DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION );
3946
3947     application.SendNotification();
3948     application.Render();
3949   }
3950
3951   {
3952     Renderer renderer = actor.GetRendererAt(0);
3953     actor.RemoveRenderer(renderer);
3954     DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
3955
3956     application.SendNotification();
3957     application.Render();
3958   }
3959
3960   // Call one final time to ensure that the renderer is actually removed after
3961   // the handle goes out of scope, and excercises the deletion code path in
3962   // scene graph and render.
3963   application.SendNotification();
3964   application.Render();
3965
3966   END_TEST;
3967 }
3968
3969 int UtcDaliActorRemoveRendererP2(void)
3970 {
3971   tet_infoline("Testing Actor::RemoveRenderer");
3972   TestApplication application;
3973
3974   Actor actor = Actor::New();
3975
3976   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
3977
3978   Geometry geometry = CreateQuadGeometry();
3979   Shader shader = CreateShader();
3980   Renderer renderer = Renderer::New(geometry, shader);
3981
3982   actor.AddRenderer( renderer );
3983   application.SendNotification();
3984   application.Render();
3985
3986   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
3987   DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION );
3988
3989   actor.RemoveRenderer(0);
3990   application.SendNotification();
3991   application.Render();
3992
3993   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
3994
3995   // Shut down whilst holding onto the renderer handle.
3996   END_TEST;
3997 }
3998
3999
4000 int UtcDaliActorRemoveRendererN(void)
4001 {
4002   tet_infoline("Testing Actor::RemoveRenderer");
4003   TestApplication application;
4004
4005   Actor actor = Actor::New();
4006
4007   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
4008
4009   Geometry geometry = CreateQuadGeometry();
4010   Shader shader = CreateShader();
4011   Renderer renderer = Renderer::New(geometry, shader);
4012
4013   actor.AddRenderer( renderer );
4014   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
4015   DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION );
4016
4017   actor.RemoveRenderer(10);
4018   DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION );
4019   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
4020
4021   END_TEST;
4022 }
4023
4024 // Clipping test helper functions:
4025 Actor CreateActorWithContent( uint32_t width, uint32_t height)
4026 {
4027   BufferImage image = BufferImage::New( width, height );
4028   Actor actor = CreateRenderableActor( image );
4029
4030   // Setup dimensions and position so actor is not skipped by culling.
4031   actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
4032   actor.SetSize( width, height );
4033   actor.SetParentOrigin( ParentOrigin::CENTER );
4034   actor.SetAnchorPoint( AnchorPoint::CENTER );
4035
4036   return actor;
4037 }
4038
4039 Actor CreateActorWithContent16x16()
4040 {
4041   return CreateActorWithContent( 16, 16 );
4042 }
4043
4044 void GenerateTrace( TestApplication& application, TraceCallStack& enabledDisableTrace, TraceCallStack& stencilTrace )
4045 {
4046   enabledDisableTrace.Reset();
4047   stencilTrace.Reset();
4048   enabledDisableTrace.Enable( true );
4049   stencilTrace.Enable( true );
4050
4051   application.SendNotification();
4052   application.Render();
4053
4054   enabledDisableTrace.Enable( false );
4055   stencilTrace.Enable( false );
4056 }
4057
4058 void CheckColorMask( TestGlAbstraction& glAbstraction, bool maskValue )
4059 {
4060   const TestGlAbstraction::ColorMaskParams& colorMaskParams = glAbstraction.GetColorMaskParams();
4061
4062   DALI_TEST_EQUALS<bool>( colorMaskParams.red,   maskValue, TEST_LOCATION );
4063   DALI_TEST_EQUALS<bool>( colorMaskParams.green, maskValue, TEST_LOCATION );
4064   DALI_TEST_EQUALS<bool>( colorMaskParams.blue,  maskValue, TEST_LOCATION );
4065   DALI_TEST_EQUALS<bool>( colorMaskParams.alpha, maskValue, TEST_LOCATION );
4066 }
4067
4068 int UtcDaliActorPropertyClippingP(void)
4069 {
4070   // This test checks the clippingMode property.
4071   tet_infoline( "Testing Actor::Property::ClippingMode: P" );
4072   TestApplication application;
4073
4074   Actor actor = Actor::New();
4075
4076   // Check default clippingEnabled value.
4077   Property::Value getValue( actor.GetProperty( Actor::Property::CLIPPING_MODE ) );
4078
4079   int value = 0;
4080   bool getValueResult = getValue.Get( value );
4081   DALI_TEST_CHECK( getValueResult );
4082
4083   if( getValueResult )
4084   {
4085     DALI_TEST_EQUALS<int>( value, ClippingMode::DISABLED, TEST_LOCATION );
4086   }
4087
4088   // Check setting the property to the stencil mode.
4089   actor.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
4090
4091   // Check the new value was set.
4092   getValue = actor.GetProperty( Actor::Property::CLIPPING_MODE );
4093   getValueResult = getValue.Get( value );
4094   DALI_TEST_CHECK( getValueResult );
4095
4096   if( getValueResult )
4097   {
4098     DALI_TEST_EQUALS<int>( value, ClippingMode::CLIP_CHILDREN, TEST_LOCATION );
4099   }
4100
4101   // Check setting the property to the scissor mode.
4102   actor.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4103
4104   // Check the new value was set.
4105   getValue = actor.GetProperty( Actor::Property::CLIPPING_MODE );
4106   getValueResult = getValue.Get( value );
4107   DALI_TEST_CHECK( getValueResult );
4108
4109   if( getValueResult )
4110   {
4111     DALI_TEST_EQUALS<int>( value, ClippingMode::CLIP_TO_BOUNDING_BOX, TEST_LOCATION );
4112   }
4113   END_TEST;
4114 }
4115
4116 int UtcDaliActorPropertyClippingN(void)
4117 {
4118   // Negative test case for Clipping.
4119   tet_infoline( "Testing Actor::Property::ClippingMode: N" );
4120   TestApplication application;
4121
4122   Actor actor = Actor::New();
4123
4124   // Check default clippingEnabled value.
4125   Property::Value getValue( actor.GetProperty( Actor::Property::CLIPPING_MODE ) );
4126
4127   int value = 0;
4128   bool getValueResult = getValue.Get( value );
4129   DALI_TEST_CHECK( getValueResult );
4130
4131   if( getValueResult )
4132   {
4133     DALI_TEST_EQUALS<int>( value, ClippingMode::DISABLED, TEST_LOCATION );
4134   }
4135
4136   // Check setting an invalid property value won't change the current property value.
4137   actor.SetProperty( Actor::Property::CLIPPING_MODE, "INVALID_PROPERTY" );
4138
4139   getValue = actor.GetProperty( Actor::Property::CLIPPING_MODE );
4140   getValueResult = getValue.Get( value );
4141   DALI_TEST_CHECK( getValueResult );
4142
4143   if( getValueResult )
4144   {
4145     DALI_TEST_EQUALS<int>( value, ClippingMode::DISABLED, TEST_LOCATION );
4146   }
4147
4148   END_TEST;
4149 }
4150
4151 int UtcDaliActorPropertyClippingActor(void)
4152 {
4153   // This test checks that an actor is correctly setup for clipping.
4154   tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN actor" );
4155   TestApplication application;
4156
4157   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4158   TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
4159   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4160   size_t startIndex = 0u;
4161
4162   // Create a clipping actor.
4163   Actor actorDepth1Clip = CreateActorWithContent16x16();
4164   actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
4165   Stage::GetCurrent().Add( actorDepth1Clip );
4166
4167   // Gather the call trace.
4168   GenerateTrace( application, enabledDisableTrace, stencilTrace );
4169
4170   // Check we are writing to the color buffer.
4171   CheckColorMask( glAbstraction, true );
4172
4173   // Check the stencil buffer was enabled.
4174   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "2960" ) );                                   // 2960 is GL_STENCIL_TEST
4175
4176   // Check the stencil buffer was cleared.
4177   DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "ClearStencil", "0", startIndex ) );
4178
4179   // Check the correct setup was done to write to the first bit-plane (only) of the stencil buffer.
4180   DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc",  "514, 1, 0", startIndex ) );     // 514 is GL_EQUAL, But testing no bit-planes for the first clipping node.
4181   DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask", "1", startIndex ) );
4182   DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp", "7680, 7681, 7681", startIndex ) ); // GL_KEEP, GL_REPLACE, GL_REPLACE
4183
4184   END_TEST;
4185 }
4186
4187 int UtcDaliActorPropertyClippingActorEnableThenDisable(void)
4188 {
4189   // This test checks that an actor is correctly setup for clipping and then correctly setup when clipping is disabled
4190   tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN actor enable and then disable" );
4191   TestApplication application;
4192
4193   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4194   TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
4195   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4196   size_t startIndex = 0u;
4197
4198   // Create a clipping actor.
4199   Actor actorDepth1Clip = CreateActorWithContent16x16();
4200   actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
4201   Stage::GetCurrent().Add( actorDepth1Clip );
4202
4203   // Gather the call trace.
4204   GenerateTrace( application, enabledDisableTrace, stencilTrace );
4205
4206   // Check we are writing to the color buffer.
4207   CheckColorMask( glAbstraction, true );
4208
4209   // Check the stencil buffer was enabled.
4210   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "2960" ) );                                   // 2960 is GL_STENCIL_TEST
4211
4212   // Check the stencil buffer was cleared.
4213   DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "ClearStencil", "0", startIndex ) );
4214
4215   // Check the correct setup was done to write to the first bit-plane (only) of the stencil buffer.
4216   DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc",  "514, 1, 0", startIndex ) );     // 514 is GL_EQUAL, But testing no bit-planes for the first clipping node.
4217   DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask", "1", startIndex ) );
4218   DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp", "7680, 7681, 7681", startIndex ) ); // GL_KEEP, GL_REPLACE, GL_REPLACE
4219
4220   // Now disable the clipping
4221   actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::DISABLED );
4222
4223   // Gather the call trace.
4224   GenerateTrace( application, enabledDisableTrace, stencilTrace );
4225
4226   // Check the stencil buffer was disabled.
4227   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Disable", "2960" ) );                                   // 2960 is GL_STENCIL_TEST
4228
4229   // Ensure all values in stencil-mask are set to 1.
4230   startIndex = 0u;
4231   DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask", "255", startIndex ) );
4232
4233   END_TEST;
4234 }
4235
4236 int UtcDaliActorPropertyClippingNestedChildren(void)
4237 {
4238   // This test checks that a hierarchy of actors are clipped correctly by
4239   // writing to and reading from the correct bit-planes of the stencil buffer.
4240   tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN nested children" );
4241   TestApplication application;
4242   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4243   TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
4244   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4245
4246   // Create a clipping actor.
4247   Actor actorDepth1Clip = CreateActorWithContent16x16();
4248   actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
4249   Stage::GetCurrent().Add( actorDepth1Clip );
4250
4251   // Create a child actor.
4252   Actor childDepth2 = CreateActorWithContent16x16();
4253   actorDepth1Clip.Add( childDepth2 );
4254
4255   // Create another clipping actor.
4256   Actor childDepth2Clip = CreateActorWithContent16x16();
4257   childDepth2Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
4258   childDepth2.Add( childDepth2Clip );
4259
4260   // Create another 2 child actors. We do this so 2 nodes will have the same clipping ID.
4261   // This tests the sort algorithm.
4262   Actor childDepth3 = CreateActorWithContent16x16();
4263   childDepth2Clip.Add( childDepth3 );
4264   Actor childDepth4 = CreateActorWithContent16x16();
4265   childDepth3.Add( childDepth4 );
4266
4267   // Gather the call trace.
4268   GenerateTrace( application, enabledDisableTrace, stencilTrace );
4269
4270   // Check we are writing to the color buffer.
4271   CheckColorMask( glAbstraction, true );
4272
4273   // Check the stencil buffer was enabled.
4274   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "2960" ) );                                        // 2960 is GL_STENCIL_TEST
4275
4276   // Perform the test twice, once for 2D layer, and once for 3D.
4277   for( unsigned int i = 0u ; i < 2u; ++i )
4278   {
4279     size_t startIndex = 0u;
4280
4281     // Check the stencil buffer was cleared.
4282     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "ClearStencil", "0", startIndex ) );
4283
4284     // Check the correct setup was done to write to the first bit-plane (only) of the stencil buffer.
4285     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc",  "514, 1, 0", startIndex ) );        // 514 is GL_EQUAL, But testing no bit-planes for the first clipping node.
4286     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask",  "1", startIndex ) );                // Write to the first bit-plane
4287     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp",    "7680, 7681, 7681", startIndex ) ); // GL_KEEP, GL_REPLACE, GL_REPLACE
4288
4289     // Check the correct setup was done to test against first bit-plane (only) of the stencil buffer.
4290     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc",  "514, 1, 255", startIndex ) );      // 514 is GL_EQUAL
4291     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp",    "7680, 7680, 7680", startIndex ) ); // GL_KEEP, GL_KEEP, GL_KEEP
4292
4293     // Check we are set up to write to the second bitplane of the stencil buffer (only).
4294     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc",  "514, 3, 1", startIndex ) );        // 514 is GL_EQUAL, Test both bit-planes 1 & 2
4295     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask",  "3", startIndex ) );                // Write to second (and previous) bit-planes
4296     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp",    "7680, 7681, 7681", startIndex ) ); // GL_KEEP, GL_REPLACE, GL_REPLACE
4297
4298     // Check we are set up to test against both the first and second bit-planes of the stencil buffer.
4299     // (Both must be set to pass the check).
4300     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc",  "514, 3, 255", startIndex ) );      // 514 is GL_EQUAL, Test both bit-planes 1 & 2
4301     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp",    "7680, 7680, 7680", startIndex ) ); // GL_KEEP, GL_KEEP, GL_KEEP
4302
4303     // If we are on the first loop, set the layer to 3D and loop to perform the test again.
4304     if( i == 0u )
4305     {
4306       Stage::GetCurrent().GetRootLayer().SetBehavior( Layer::LAYER_3D );
4307       GenerateTrace( application, enabledDisableTrace, stencilTrace );
4308     }
4309   }
4310
4311   END_TEST;
4312 }
4313
4314 int UtcDaliActorPropertyClippingActorDrawOrder(void)
4315 {
4316   // This test checks that a hierarchy of actors are drawn in the correct order when clipping is enabled.
4317   tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN draw order" );
4318   TestApplication application;
4319   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4320   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4321
4322   /* We create a small tree of actors as follows:
4323
4324                            A
4325                           / \
4326      Clipping enabled -> B   D
4327                          |   |
4328                          C   E
4329
4330      The correct draw order is "ABCDE" (the same as if clipping was not enabled).
4331   */
4332   Actor actors[5];
4333   for( int i = 0; i < 5; ++i )
4334   {
4335     BufferImage image = BufferImage::New( 16u, 16u );
4336     Actor actor = CreateRenderableActor( image );
4337
4338     // Setup dimensions and position so actor is not skipped by culling.
4339     actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
4340     actor.SetSize( 16.0f, 16.0f );
4341
4342     if( i == 0 )
4343     {
4344       actor.SetParentOrigin( ParentOrigin::CENTER );
4345     }
4346     else
4347     {
4348       float b = i > 2 ? 1.0f : -1.0f;
4349       actor.SetParentOrigin( Vector3( 0.5 + ( 0.2f * b ), 0.8f, 0.8f ) );
4350     }
4351
4352     actors[i] = actor;
4353   }
4354
4355   // Enable clipping on the actor at the top of the left branch.
4356   actors[1].SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
4357
4358   // Build the scene graph.
4359   Stage::GetCurrent().Add( actors[0] );
4360
4361   // Left branch:
4362   actors[0].Add( actors[1] );
4363   actors[1].Add( actors[2] );
4364
4365   // Right branch:
4366   actors[0].Add( actors[3] );
4367   actors[3].Add( actors[4] );
4368
4369   // Gather the call trace.
4370   enabledDisableTrace.Reset();
4371   enabledDisableTrace.Enable( true );
4372   application.SendNotification();
4373   application.Render();
4374   enabledDisableTrace.Enable( false );
4375
4376   /* Check stencil is enabled and disabled again (as right-hand branch of tree is drawn).
4377
4378      Note: Correct enable call trace:    StackTrace: Index:0, Function:Enable, ParamList:3042 StackTrace: Index:1, Function:Enable, ParamList:2960 StackTrace: Index:2, Function:Disable, ParamList:2960
4379            Incorrect enable call trace:  StackTrace: Index:0, Function:Enable, ParamList:3042 StackTrace: Index:1, Function:Enable, ParamList:2960
4380   */
4381   size_t startIndex = 0u;
4382   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Enable",  "3042", startIndex ) );
4383   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Enable",  "2960", startIndex ) ); // 2960 is GL_STENCIL_TEST
4384   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Disable", "2960", startIndex ) );
4385
4386   // Swap the clipping actor from top of left branch to top of right branch.
4387   actors[1].SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::DISABLED );
4388   actors[3].SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
4389
4390   // Gather the call trace.
4391   enabledDisableTrace.Reset();
4392   enabledDisableTrace.Enable( true );
4393   application.SendNotification();
4394   application.Render();
4395   enabledDisableTrace.Enable( false );
4396
4397   // Check stencil is enabled but NOT disabled again (as right-hand branch of tree is drawn).
4398   // This proves the draw order has remained the same.
4399   startIndex = 0u;
4400   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex(  "Enable",  "2960", startIndex ) );
4401   DALI_TEST_CHECK( !enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Disable", "2960", startIndex ) );
4402
4403   END_TEST;
4404 }
4405
4406 int UtcDaliActorPropertyScissorClippingActor(void)
4407 {
4408   // This test checks that an actor is correctly setup for clipping.
4409   tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor" );
4410   TestApplication application;
4411
4412   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4413   TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
4414   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4415
4416   const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
4417   const Vector2 imageSize( 16.0f, 16.0f );
4418
4419   // Create a clipping actor.
4420   Actor clippingActorA = CreateActorWithContent16x16();
4421   // Note: Scissor coords are have flipped Y values compared with DALi's coordinate system.
4422   // We choose BOTTOM_LEFT to give us x=0, y=0 starting coordinates for the first test.
4423   clippingActorA.SetParentOrigin( ParentOrigin::BOTTOM_LEFT );
4424   clippingActorA.SetAnchorPoint( AnchorPoint::BOTTOM_LEFT );
4425   clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4426   Stage::GetCurrent().Add( clippingActorA );
4427
4428   // Gather the call trace.
4429   GenerateTrace( application, enabledDisableTrace, scissorTrace );
4430
4431   // Check we are writing to the color buffer.
4432   CheckColorMask( glAbstraction, true );
4433
4434   // Check scissor test was enabled.
4435   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) );                                   // 3089 = 0xC11 (GL_SCISSOR_TEST)
4436
4437   // Check the scissor was set, and the coordinates are correct.
4438   std::stringstream compareParametersString;
4439   compareParametersString << "0, 0, " << imageSize.x << ", " << imageSize.y;
4440   DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", compareParametersString.str() ) );                  // Compare with 0, 0, 16, 16
4441
4442   clippingActorA.SetParentOrigin( ParentOrigin::TOP_RIGHT );
4443   clippingActorA.SetAnchorPoint( AnchorPoint::TOP_RIGHT );
4444
4445   // Gather the call trace.
4446   GenerateTrace( application, enabledDisableTrace, scissorTrace );
4447
4448   // Check the scissor was set, and the coordinates are correct.
4449   compareParametersString.str( std::string() );
4450   compareParametersString.clear();
4451   compareParametersString << ( stageSize.x - imageSize.x ) << ", " << ( stageSize.y - imageSize.y ) << ", " << imageSize.x << ", " << imageSize.y;
4452   DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", compareParametersString.str() ) );                  // Compare with 464, 784, 16, 16
4453
4454   END_TEST;
4455 }
4456
4457 int UtcDaliActorPropertyScissorClippingActorSiblings(void)
4458 {
4459   // This test checks that an actor is correctly setup for clipping.
4460   tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actors which are siblings" );
4461   TestApplication application;
4462
4463
4464   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4465   TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
4466   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4467
4468   const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
4469   const Vector2 sizeA{ stageSize.width, stageSize.height * 0.25f };
4470   const Vector2 sizeB{ stageSize.width, stageSize.height * 0.05f };
4471
4472   // Create a clipping actors.
4473   Actor clippingActorA = CreateActorWithContent( sizeA.width, sizeA.height );
4474   Actor clippingActorB = CreateActorWithContent( sizeB.width, sizeB.height );
4475
4476   clippingActorA.SetParentOrigin( ParentOrigin::CENTER_LEFT );
4477   clippingActorA.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
4478   clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4479
4480   clippingActorB.SetParentOrigin( ParentOrigin::CENTER_LEFT );
4481   clippingActorB.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
4482   clippingActorB.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4483
4484   clippingActorA.SetPosition( 0.0f, -200.0f, 0.0f );
4485   clippingActorB.SetPosition( 0.0f, 0.0f, 0.0f );
4486
4487   Stage::GetCurrent().Add( clippingActorA );
4488   Stage::GetCurrent().Add( clippingActorB );
4489
4490   // Gather the call trace.
4491   GenerateTrace( application, enabledDisableTrace, scissorTrace );
4492
4493   // Check we are writing to the color buffer.
4494   CheckColorMask( glAbstraction, true );
4495
4496   // Check scissor test was enabled.
4497   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) );                                   // 3089 = 0xC11 (GL_SCISSOR_TEST)
4498
4499   // Check the scissor was set, and the coordinates are correct.
4500   std::stringstream compareParametersString;
4501
4502   std::string clipA( "0, 500, 480, 200" );
4503   std::string clipB( "0, 380, 480, 40" );
4504
4505   DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipA ) );
4506   DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipB ) );
4507
4508   END_TEST;
4509 }
4510
4511 int UtcDaliActorPropertyScissorClippingActorNested01(void)
4512 {
4513   // This test checks that an actor is correctly setup for clipping.
4514   tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor nested" );
4515   TestApplication application;
4516
4517   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4518   TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
4519   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4520
4521   const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
4522   const Vector2 imageSize( 16.0f, 16.0f );
4523
4524   /* Create a nest of 2 scissors to test nesting (intersecting clips).
4525
4526      A is drawn first - with scissor clipping on
4527      B is drawn second - also with scissor clipping on
4528      C is the generated clipping region, the intersection ( A ∩ B )
4529
4530            ┏━━━━━━━┓                   ┌───────┐
4531            ┃     B ┃                   │     B │
4532        ┌───╂┄┄┄┐   ┃               ┌┄┄┄╆━━━┓   │
4533        │   ┃   ┊   ┃     ━━━━━>    ┊   ┃ C ┃   │
4534        │   ┗━━━┿━━━┛               ┊   ┗━━━╃───┘
4535        │ A     │                   ┊ A     ┊
4536        └───────┘                   └┄┄┄┄┄┄┄┘
4537
4538      We then reposition B around each corner of A to test the 4 overlap combinations (thus testing intersecting works correctly).
4539   */
4540
4541   // Create a clipping actor.
4542   Actor clippingActorA = CreateActorWithContent16x16();
4543   // Note: Scissor coords are have flipped Y values compared with DALi's coordinate system.
4544   // We choose BOTTOM_LEFT to give us x=0, y=0 starting coordinates for the first test.
4545   clippingActorA.SetParentOrigin( ParentOrigin::CENTER );
4546   clippingActorA.SetAnchorPoint( AnchorPoint::CENTER );
4547   clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4548   Stage::GetCurrent().Add( clippingActorA );
4549
4550   // Create a child clipping actor.
4551   Actor clippingActorB = CreateActorWithContent16x16();
4552   clippingActorB.SetParentOrigin( ParentOrigin::CENTER );
4553   clippingActorB.SetAnchorPoint( AnchorPoint::CENTER );
4554   clippingActorB.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4555   clippingActorA.Add( clippingActorB );
4556
4557   // positionModifiers is an array of positions to position B around.
4558   // expect is an array of expected scissor clip coordinate results.
4559   const Vector2 positionModifiers[4] = { Vector2( 1.0f, 1.0f ),     Vector2( -1.0f, 1.0f ),    Vector2( -1.0f, -1.0f ),   Vector2( 1.0f, -1.0f )    };
4560   const Vector4 expect[4] =            { Vector4( 240, 392, 8, 8 ), Vector4( 232, 392, 8, 8 ), Vector4( 232, 400, 8, 8 ), Vector4( 240, 400, 8, 8 ) };
4561
4562   // Loop through each overlap combination.
4563   for( unsigned int test = 0u; test < 4u; ++test )
4564   {
4565     // Position the child clipping actor so it intersects with the 1st clipping actor. This changes each loop.
4566     const Vector2 position = ( imageSize / 2.0f ) * positionModifiers[test];
4567     clippingActorB.SetPosition( position.x, position.y );
4568
4569     // Gather the call trace.
4570     GenerateTrace( application, enabledDisableTrace, scissorTrace );
4571
4572     // Check we are writing to the color buffer.
4573     CheckColorMask( glAbstraction, true );
4574
4575     // Check scissor test was enabled.
4576     DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) );                                   // 3089 = 0xC11 (GL_SCISSOR_TEST)
4577
4578     // Check the scissor was set, and the coordinates are correct.
4579     const Vector4& expectResults( expect[test] );
4580     std::stringstream compareParametersString;
4581     compareParametersString << expectResults.x << ", " << expectResults.y << ", " << expectResults.z << ", " << expectResults.w;
4582     DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", compareParametersString.str() ) );                  // Compare with the expected result
4583   }
4584
4585   END_TEST;
4586 }
4587
4588 int UtcDaliActorPropertyScissorClippingActorNested02(void)
4589 {
4590   // This test checks that an actor is correctly setup for clipping.
4591   tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor nested" );
4592   TestApplication application;
4593
4594   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4595   TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
4596   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4597
4598   /* Create a nest of 2 scissors and siblings of the parent.
4599
4600             stage
4601               |
4602         ┌─────┐─────┐
4603         A     C     D
4604         |           |
4605         B           E
4606   */
4607
4608   const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
4609   const Vector2 sizeA{ stageSize.width, stageSize.height * 0.25f };
4610   const Vector2 sizeB{ stageSize.width, stageSize.height * 0.05f };
4611   const Vector2 sizeC{ stageSize.width, stageSize.height * 0.25f };
4612   const Vector2 sizeD{ stageSize.width, stageSize.height * 0.25f };
4613   const Vector2 sizeE{ stageSize.width, stageSize.height * 0.05f };
4614
4615   // Create a clipping actors.
4616   Actor clippingActorA = CreateActorWithContent( sizeA.width, sizeA.height );
4617   Actor clippingActorB = CreateActorWithContent( sizeB.width, sizeB.height );
4618   Actor clippingActorC = CreateActorWithContent( sizeC.width, sizeC.height );
4619   Actor clippingActorD = CreateActorWithContent( sizeD.width, sizeD.height );
4620   Actor clippingActorE = CreateActorWithContent( sizeE.width, sizeE.height );
4621
4622   clippingActorA.SetParentOrigin( ParentOrigin::CENTER_LEFT );
4623   clippingActorA.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
4624   clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4625
4626   clippingActorB.SetParentOrigin( ParentOrigin::CENTER_LEFT );
4627   clippingActorB.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
4628   clippingActorB.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4629
4630   clippingActorC.SetParentOrigin( ParentOrigin::CENTER_LEFT );
4631   clippingActorC.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
4632   clippingActorC.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4633
4634   clippingActorD.SetParentOrigin( ParentOrigin::CENTER_LEFT );
4635   clippingActorD.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
4636   clippingActorD.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4637
4638   clippingActorE.SetParentOrigin( ParentOrigin::CENTER_LEFT );
4639   clippingActorE.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
4640
4641   clippingActorA.SetPosition( 0.0f, -200.0f, 0.0f );
4642   clippingActorB.SetPosition( 0.0f, 0.0f, 0.0f );
4643   clippingActorC.SetPosition( 0.0f, 100.0f, 0.0f );
4644   clippingActorD.SetPosition( 0.0f, 0.0f, 0.0f );
4645   clippingActorE.SetPosition( 0.0f, 0.0f, 0.0f );
4646
4647   Stage::GetCurrent().Add( clippingActorA );
4648   clippingActorA.Add( clippingActorB );
4649   Stage::GetCurrent().Add( clippingActorC );
4650   Stage::GetCurrent().Add( clippingActorD );
4651   clippingActorD.Add( clippingActorE );
4652
4653   // Gather the call trace.
4654   GenerateTrace( application, enabledDisableTrace, scissorTrace );
4655
4656   // Check we are writing to the color buffer.
4657   CheckColorMask( glAbstraction, true );
4658
4659   // Check scissor test was enabled.
4660   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) );                                   // 3089 = 0xC11 (GL_SCISSOR_TEST)
4661
4662   // Check the scissor was set, and the coordinates are correct.
4663   std::string clipA( "0, 500, 480, 200" );
4664   std::string clipB( "0, 580, 480, 40" );
4665   std::string clipC( "0, 200, 480, 200" );
4666   std::string clipD( "0, 300, 480, 200" );
4667
4668   DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipA ) );
4669   DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipB ) );
4670   DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipC ) );
4671   DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipD ) );
4672   DALI_TEST_CHECK( scissorTrace.CountMethod( "Scissor" ) == 4 );    // Scissor rect should not be changed in clippingActorE case. So count should be 4.
4673
4674   END_TEST;
4675 }
4676
4677 int UtcDaliActorPropertyClippingActorWithRendererOverride(void)
4678 {
4679   // This test checks that an actor with clipping will be ignored if overridden by the Renderer properties.
4680   tet_infoline( "Testing Actor::Property::CLIPPING_MODE actor with renderer override" );
4681   TestApplication application;
4682
4683   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4684   TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
4685   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4686
4687   // Create a clipping actor.
4688   Actor actorDepth1Clip = CreateActorWithContent16x16();
4689   actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
4690   Stage::GetCurrent().Add( actorDepth1Clip );
4691
4692   // Turn the RenderMode to just "COLOR" at the Renderer level to ignore the clippingMode.
4693   actorDepth1Clip.GetRendererAt( 0 ).SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR );
4694
4695   // Gather the call trace.
4696   GenerateTrace( application, enabledDisableTrace, stencilTrace );
4697
4698   // Check we are writing to the color buffer.
4699   CheckColorMask( glAbstraction, true );
4700
4701   // Check the stencil buffer was not enabled.
4702   DALI_TEST_CHECK( !enabledDisableTrace.FindMethodAndParams( "Enable", "2960" ) );    // 2960 is GL_STENCIL_TEST
4703
4704   // Check stencil functions are not called.
4705   DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilFunc" ) );
4706   DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilMask" ) );
4707   DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilOp" ) );
4708
4709   // Check that scissor clipping is overriden by the renderer properties.
4710   TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
4711
4712   actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4713
4714   // Gather the call trace.
4715   GenerateTrace( application, enabledDisableTrace, scissorTrace );
4716
4717   // Check the stencil buffer was not enabled.
4718   DALI_TEST_CHECK( !enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) );    // 3089 = 0xC11 (GL_SCISSOR_TEST)
4719
4720   DALI_TEST_CHECK( !scissorTrace.FindMethod( "StencilFunc" ) );
4721
4722   END_TEST;
4723 }
4724
4725 int UtcDaliGetPropertyN(void)
4726 {
4727   tet_infoline( "Testing Actor::GetProperty returns a non valid value if property index is out of range" );
4728   TestApplication app;
4729
4730   Actor actor = Actor::New();
4731
4732   unsigned int propertyCount = actor.GetPropertyCount();
4733   DALI_TEST_EQUALS( actor.GetProperty( Property::Index(propertyCount)).GetType(), Property::NONE, TEST_LOCATION );
4734   END_TEST;
4735 }
4736
4737 int UtcDaliActorRaiseLower(void)
4738 {
4739   tet_infoline( "UtcDaliActor Raise and Lower test\n" );
4740
4741   TestApplication application;
4742
4743   Stage stage( Stage::GetCurrent() );
4744
4745   Actor actorA = Actor::New();
4746   Actor actorB = Actor::New();
4747   Actor actorC = Actor::New();
4748
4749   actorA.SetAnchorPoint( AnchorPoint::CENTER );
4750   actorA.SetParentOrigin( ParentOrigin::CENTER );
4751
4752   actorB.SetAnchorPoint( AnchorPoint::CENTER );
4753   actorB.SetParentOrigin( ParentOrigin::CENTER );
4754
4755   actorC.SetAnchorPoint( AnchorPoint::CENTER );
4756   actorC.SetParentOrigin( ParentOrigin::CENTER );
4757
4758   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
4759   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
4760
4761   actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
4762   actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
4763
4764   actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
4765   actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
4766
4767   stage.Add( actorA );
4768   stage.Add( actorB );
4769   stage.Add( actorC );
4770
4771   ResetTouchCallbacks();
4772
4773   application.SendNotification();
4774   application.Render();
4775
4776   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
4777   DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
4778   DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
4779
4780   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
4781   // Only top actor will get touched.
4782   actorA.TouchSignal().Connect( TestTouchCallback );
4783   actorB.TouchSignal().Connect( TestTouchCallback2 );
4784   actorC.TouchSignal().Connect( TestTouchCallback3 );
4785
4786   // Connect ChildOrderChangedSignal
4787   bool orderChangedSignal( false );
4788   Actor orderChangedActor;
4789   ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
4790   DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
4791
4792   Dali::Integration::Point point;
4793   point.SetDeviceId( 1 );
4794   point.SetState( PointState::DOWN );
4795   point.SetScreenPosition( Vector2( 10.f, 10.f ) );
4796   Dali::Integration::TouchEvent touchEvent;
4797   touchEvent.AddPoint( point );
4798
4799   application.ProcessEvent( touchEvent );
4800
4801   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
4802   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
4803   DALI_TEST_EQUALS( gTouchCallBackCalled3,  true , TEST_LOCATION );
4804
4805   ResetTouchCallbacks();
4806
4807   tet_printf( "Testing Raising of Actor\n" );
4808
4809   int preActorOrder( 0 );
4810   int postActorOrder( 0 );
4811
4812   Property::Value value  = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
4813   value.Get( preActorOrder );
4814
4815   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
4816   actorB.Raise();
4817   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
4818   DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
4819
4820   // Ensure sort order is calculated before next touch event
4821   application.SendNotification();
4822
4823   value  = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
4824   value.Get( postActorOrder );
4825
4826   tet_printf( "Raised ActorB from (%d) to (%d) \n", preActorOrder, postActorOrder );
4827
4828   application.ProcessEvent( touchEvent );
4829
4830   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
4831   DALI_TEST_EQUALS( gTouchCallBackCalled2,  true , TEST_LOCATION );
4832   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false, TEST_LOCATION );
4833
4834   ResetTouchCallbacks();
4835
4836   tet_printf( "Testing Lowering of Actor\n" );
4837
4838   value  = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
4839   value.Get( preActorOrder );
4840
4841   orderChangedSignal = false;
4842
4843   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
4844   actorB.Lower();
4845   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
4846   DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
4847
4848   application.SendNotification(); // ensure sort order calculated before next touch event
4849
4850   value  = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
4851   value.Get( postActorOrder );
4852
4853   tet_printf( "Lowered ActorB from (%d) to (%d) \n", preActorOrder, postActorOrder );
4854
4855   application.ProcessEvent( touchEvent );
4856
4857   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
4858   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false , TEST_LOCATION );
4859   DALI_TEST_EQUALS( gTouchCallBackCalled3,  true, TEST_LOCATION );
4860
4861   ResetTouchCallbacks();
4862
4863   END_TEST;
4864 }
4865
4866 int UtcDaliActorRaiseToTopLowerToBottom(void)
4867 {
4868   tet_infoline( "UtcDaliActorRaiseToTop and LowerToBottom test \n" );
4869
4870   TestApplication application;
4871
4872   Stage stage( Stage::GetCurrent() );
4873
4874   Actor actorA = Actor::New();
4875   Actor actorB = Actor::New();
4876   Actor actorC = Actor::New();
4877
4878   // Set up renderers to add to Actors, float value 1, 2, 3 assigned to each
4879   // enables checking of which actor the uniform is assigned too
4880   Shader shaderA = CreateShader();
4881   shaderA.RegisterProperty( "uRendererColor",1.f);
4882
4883   Shader shaderB = CreateShader();
4884   shaderB.RegisterProperty( "uRendererColor", 2.f );
4885
4886   Shader shaderC = CreateShader();
4887   shaderC.RegisterProperty( "uRendererColor", 3.f );
4888
4889   Geometry geometry = CreateQuadGeometry();
4890
4891   // Add renderers to Actors so ( uRendererColor, 1 ) is A, ( uRendererColor, 2 ) is B, and ( uRendererColor, 3 ) is C,
4892   Renderer rendererA = Renderer::New(geometry, shaderA);
4893   actorA.AddRenderer(rendererA);
4894
4895   Renderer rendererB = Renderer::New(geometry, shaderB);
4896   actorB.AddRenderer(rendererB);
4897
4898   Renderer rendererC = Renderer::New(geometry, shaderC);
4899   actorC.AddRenderer(rendererC);
4900
4901   actorA.SetAnchorPoint( AnchorPoint::CENTER );
4902   actorA.SetParentOrigin( ParentOrigin::CENTER );
4903
4904   actorB.SetAnchorPoint( AnchorPoint::CENTER );
4905   actorB.SetParentOrigin( ParentOrigin::CENTER );
4906
4907   actorC.SetAnchorPoint( AnchorPoint::CENTER );
4908   actorC.SetParentOrigin( ParentOrigin::CENTER );
4909
4910   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
4911   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
4912
4913   actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
4914   actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
4915
4916   actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
4917   actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
4918
4919   stage.Add( actorA );
4920   stage.Add( actorB );
4921   stage.Add( actorC );
4922
4923   ResetTouchCallbacks();
4924
4925   // Connect ChildOrderChangedSignal
4926   bool orderChangedSignal( false );
4927   Actor orderChangedActor;
4928   ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
4929   DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
4930
4931   // Set up gl abstraction trace so can query the set uniform order
4932   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4933   glAbstraction.EnableSetUniformCallTrace(true);
4934   glAbstraction.ResetSetUniformCallStack();
4935
4936   TraceCallStack& glSetUniformStack = glAbstraction.GetSetUniformTrace();
4937
4938   application.SendNotification();
4939   application.Render();
4940
4941   tet_printf( "Trace Output:%s \n", glSetUniformStack.GetTraceString().c_str() );
4942
4943
4944   // Test order of uniforms in stack
4945   int indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "3" );
4946   int indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "2" );
4947   int indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "1" );
4948
4949   bool CBA = ( indexC > indexB) &&  ( indexB > indexA );
4950
4951   DALI_TEST_EQUALS( CBA, true, TEST_LOCATION );
4952
4953   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
4954   DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
4955   DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
4956
4957   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
4958   // Only top actor will get touched.
4959   actorA.TouchSignal().Connect( TestTouchCallback );
4960   actorB.TouchSignal().Connect( TestTouchCallback2 );
4961   actorC.TouchSignal().Connect( TestTouchCallback3 );
4962
4963   Dali::Integration::Point point;
4964   point.SetDeviceId( 1 );
4965   point.SetState( PointState::DOWN );
4966   point.SetScreenPosition( Vector2( 10.f, 10.f ) );
4967   Dali::Integration::TouchEvent touchEvent;
4968   touchEvent.AddPoint( point );
4969
4970   application.ProcessEvent( touchEvent );
4971
4972   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
4973   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
4974   DALI_TEST_EQUALS( gTouchCallBackCalled3,  true , TEST_LOCATION );
4975
4976   ResetTouchCallbacks();
4977
4978   tet_printf( "RaiseToTop ActorA\n" );
4979
4980   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
4981   actorA.RaiseToTop();
4982   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
4983   DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
4984
4985   application.SendNotification(); // ensure sorting order is calculated before next touch event
4986
4987   application.ProcessEvent( touchEvent );
4988
4989   glAbstraction.ResetSetUniformCallStack();
4990   glSetUniformStack = glAbstraction.GetSetUniformTrace();
4991
4992   application.SendNotification();
4993   application.Render();
4994
4995   tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
4996
4997   // Test order of uniforms in stack
4998   indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "3" );
4999   indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "2" );
5000   indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "1" );
5001
5002   tet_infoline( "Testing A above C and B at bottom\n" );
5003   bool ACB = ( indexA > indexC) && ( indexC > indexB );
5004
5005   DALI_TEST_EQUALS( ACB, true, TEST_LOCATION );
5006
5007   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5008   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5009   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5010
5011   ResetTouchCallbacks();
5012
5013   tet_printf( "RaiseToTop ActorB\n" );
5014
5015   orderChangedSignal = false;
5016
5017   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5018   actorB.RaiseToTop();
5019   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5020   DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
5021
5022   application.SendNotification(); // Ensure sort order is calculated before next touch event
5023
5024   application.ProcessEvent( touchEvent );
5025
5026   glAbstraction.ResetSetUniformCallStack();
5027   glSetUniformStack = glAbstraction.GetSetUniformTrace();
5028
5029   application.SendNotification();
5030   application.Render();
5031
5032   tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
5033
5034   // Test order of uniforms in stack
5035   indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "3" );
5036   indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "2" );
5037   indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "1" );
5038
5039   tet_infoline( "Testing B above A and C at bottom\n" );
5040   bool BAC = ( indexB > indexA ) && ( indexA > indexC );
5041
5042   DALI_TEST_EQUALS( BAC, true, TEST_LOCATION );
5043
5044   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5045   DALI_TEST_EQUALS( gTouchCallBackCalled2,  true, TEST_LOCATION );
5046   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5047
5048   ResetTouchCallbacks();
5049
5050   tet_printf( "LowerToBottom ActorA then ActorB leaving Actor C at Top\n" );
5051
5052   orderChangedSignal = false;
5053
5054   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5055   actorA.LowerToBottom();
5056   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5057   DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
5058
5059   application.SendNotification();
5060   application.Render();
5061
5062   orderChangedSignal = false;
5063
5064   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5065   actorB.LowerToBottom();
5066   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5067   DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
5068
5069   application.SendNotification();
5070   application.Render();
5071
5072   application.ProcessEvent( touchEvent );
5073
5074   glAbstraction.ResetSetUniformCallStack();
5075   glSetUniformStack = glAbstraction.GetSetUniformTrace();
5076
5077   application.SendNotification();
5078   application.Render();
5079
5080   tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
5081
5082   // Test order of uniforms in stack
5083   indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "3" );
5084   indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "2" );
5085   indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "1" );
5086
5087   tet_infoline( "Testing C above A and B at bottom\n" );
5088   bool CAB = ( indexC > indexA ) && ( indexA > indexB );
5089
5090   DALI_TEST_EQUALS( CAB, true, TEST_LOCATION );
5091
5092   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5093   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5094   DALI_TEST_EQUALS( gTouchCallBackCalled3,  true , TEST_LOCATION );
5095
5096   ResetTouchCallbacks();
5097
5098   END_TEST;
5099 }
5100
5101 int UtcDaliActorRaiseAbove(void)
5102 {
5103   tet_infoline( "UtcDaliActor RaiseToAbove test \n" );
5104
5105   TestApplication application;
5106
5107   Stage stage( Stage::GetCurrent() );
5108
5109   Actor actorA = Actor::New();
5110   Actor actorB = Actor::New();
5111   Actor actorC = Actor::New();
5112
5113   actorA.SetAnchorPoint( AnchorPoint::CENTER );
5114   actorA.SetParentOrigin( ParentOrigin::CENTER );
5115
5116   actorB.SetAnchorPoint( AnchorPoint::CENTER );
5117   actorB.SetParentOrigin( ParentOrigin::CENTER );
5118
5119   actorC.SetAnchorPoint( AnchorPoint::CENTER );
5120   actorC.SetParentOrigin( ParentOrigin::CENTER );
5121
5122   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5123   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5124
5125   actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5126   actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5127
5128   actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5129   actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5130
5131   stage.Add( actorA );
5132   stage.Add( actorB );
5133   stage.Add( actorC );
5134
5135   ResetTouchCallbacks();
5136
5137   application.SendNotification();
5138   application.Render();
5139
5140   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
5141   DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
5142   DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
5143
5144   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
5145   // Only top actor will get touched.
5146   actorA.TouchSignal().Connect( TestTouchCallback );
5147   actorB.TouchSignal().Connect( TestTouchCallback2 );
5148   actorC.TouchSignal().Connect( TestTouchCallback3 );
5149
5150   bool orderChangedSignal( false );
5151   Actor orderChangedActor;
5152   ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
5153   DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
5154
5155   Dali::Integration::Point point;
5156   point.SetDeviceId( 1 );
5157   point.SetState( PointState::DOWN );
5158   point.SetScreenPosition( Vector2( 10.f, 10.f ) );
5159   Dali::Integration::TouchEvent touchEvent;
5160   touchEvent.AddPoint( point );
5161
5162   application.ProcessEvent( touchEvent );
5163
5164   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5165   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5166   DALI_TEST_EQUALS( gTouchCallBackCalled3,  true , TEST_LOCATION );
5167
5168   ResetTouchCallbacks();
5169
5170   tet_printf( "Raise actor B Above Actor C\n" );
5171
5172   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5173   actorB.RaiseAbove( actorC );
5174   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5175   DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
5176
5177   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5178   application.SendNotification();
5179   application.ProcessEvent( touchEvent );
5180
5181   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5182   DALI_TEST_EQUALS( gTouchCallBackCalled2,  true, TEST_LOCATION );
5183   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5184
5185   ResetTouchCallbacks();
5186
5187   tet_printf( "Raise actor A Above Actor B\n" );
5188
5189   orderChangedSignal = false;
5190
5191   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5192   actorA.RaiseAbove( actorB );
5193   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5194   DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
5195
5196   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5197   application.SendNotification();
5198
5199   application.ProcessEvent( touchEvent ); // process a touch event on ordered actors.
5200
5201   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5202   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5203   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5204
5205   ResetTouchCallbacks();
5206
5207   END_TEST;
5208 }
5209
5210 int UtcDaliActorLowerBelow(void)
5211 {
5212   tet_infoline( "UtcDaliActor LowerBelow test \n" );
5213
5214   TestApplication application;
5215
5216   Stage stage( Stage::GetCurrent() );
5217
5218   // Set up renderers to add to Actors, float value 1, 2, 3 assigned to each
5219   // enables checking of which actor the uniform is assigned too
5220   Shader shaderA = CreateShader();
5221   shaderA.RegisterProperty( "uRendererColor",1.f);
5222
5223   Shader shaderB = CreateShader();
5224   shaderB.RegisterProperty( "uRendererColor", 2.f );
5225
5226   Shader shaderC = CreateShader();
5227   shaderC.RegisterProperty( "uRendererColor", 3.f );
5228
5229   Actor actorA = Actor::New();
5230   Actor actorB = Actor::New();
5231   Actor actorC = Actor::New();
5232
5233   // Add renderers to Actors so ( uRendererColor, 1 ) is A, ( uRendererColor, 2 ) is B, and ( uRendererColor, 3 ) is C,
5234   Geometry geometry = CreateQuadGeometry();
5235
5236   Renderer rendererA = Renderer::New(geometry, shaderA);
5237   actorA.AddRenderer(rendererA);
5238
5239   Renderer rendererB = Renderer::New(geometry, shaderB);
5240   actorB.AddRenderer(rendererB);
5241
5242   Renderer rendererC = Renderer::New(geometry, shaderC);
5243   actorC.AddRenderer(rendererC);
5244
5245   actorA.SetAnchorPoint( AnchorPoint::CENTER );
5246   actorA.SetParentOrigin( ParentOrigin::CENTER );
5247
5248   actorB.SetAnchorPoint( AnchorPoint::CENTER );
5249   actorB.SetParentOrigin( ParentOrigin::CENTER );
5250
5251   actorC.SetAnchorPoint( AnchorPoint::CENTER );
5252   actorC.SetParentOrigin( ParentOrigin::CENTER );
5253
5254   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5255   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5256
5257   actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5258   actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5259
5260   actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5261   actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5262
5263   Actor container = Actor::New();
5264   container.SetParentOrigin( ParentOrigin::CENTER );
5265   container.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
5266   stage.Add( container );
5267
5268   container.Add( actorA );
5269   container.Add( actorB );
5270   container.Add( actorC );
5271
5272   ResetTouchCallbacks();
5273
5274   // Connect ChildOrderChangedSignal
5275   bool orderChangedSignal( false );
5276   Actor orderChangedActor;
5277   ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
5278   DevelActor::ChildOrderChangedSignal( container ).Connect( &application, f ) ;
5279
5280   // Set up gl abstraction trace so can query the set uniform order
5281   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
5282   glAbstraction.EnableSetUniformCallTrace(true);
5283   glAbstraction.ResetSetUniformCallStack();
5284   TraceCallStack& glSetUniformStack = glAbstraction.GetSetUniformTrace();
5285
5286   glAbstraction.ResetSetUniformCallStack();
5287
5288   application.SendNotification();
5289   application.Render();
5290
5291   glSetUniformStack = glAbstraction.GetSetUniformTrace();
5292
5293   tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
5294
5295   // Test order of uniforms in stack
5296   int indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "3" );
5297   int indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "2" );
5298   int indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "1" );
5299
5300   tet_infoline( "Testing C above B and A at bottom\n" );
5301   bool CBA = ( indexC > indexB) &&  ( indexB > indexA );
5302
5303   DALI_TEST_EQUALS( CBA, true, TEST_LOCATION );
5304
5305   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
5306   DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
5307   DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
5308
5309   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
5310   // Only top actor will get touched.
5311   actorA.TouchSignal().Connect( TestTouchCallback );
5312   actorB.TouchSignal().Connect( TestTouchCallback2 );
5313   actorC.TouchSignal().Connect( TestTouchCallback3 );
5314
5315   Dali::Integration::Point point;
5316   point.SetDeviceId( 1 );
5317   point.SetState( PointState::DOWN );
5318   point.SetScreenPosition( Vector2( 10.f, 10.f ) );
5319   Dali::Integration::TouchEvent touchEvent;
5320   touchEvent.AddPoint( point );
5321
5322   tet_infoline( "UtcDaliActor Test Set up completed \n" );
5323
5324   application.ProcessEvent( touchEvent );
5325
5326   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
5327   DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
5328   DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
5329
5330   ResetTouchCallbacks();
5331
5332   tet_printf( "Lower actor C below Actor B ( actor B and A on same level due to insertion order) so C is below both \n" );
5333
5334   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5335   actorC.LowerBelow( actorB );
5336   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5337   DALI_TEST_EQUALS( orderChangedActor, actorC, TEST_LOCATION );
5338
5339   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5340   application.SendNotification();
5341   application.Render();
5342
5343   application.ProcessEvent( touchEvent ); // touch event
5344
5345   glAbstraction.ResetSetUniformCallStack();
5346   glSetUniformStack = glAbstraction.GetSetUniformTrace();
5347
5348   application.SendNotification();
5349   application.Render();
5350
5351   tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
5352
5353   // Test order of uniforms in stack
5354   indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "3" );
5355   indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "2" );
5356   indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "1" );
5357
5358   tet_infoline( "Testing render order is A, C, B" );
5359   DALI_TEST_EQUALS( indexC > indexA, true, TEST_LOCATION );
5360   DALI_TEST_EQUALS( indexB > indexC, true, TEST_LOCATION );
5361
5362   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
5363   DALI_TEST_EQUALS( gTouchCallBackCalled2, true, TEST_LOCATION );
5364   DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
5365
5366   ResetTouchCallbacks();
5367
5368   tet_printf( "Lower actor C below Actor A leaving B on top\n" );
5369
5370   orderChangedSignal = false;
5371
5372   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5373   actorC.LowerBelow( actorA );
5374   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5375   DALI_TEST_EQUALS( orderChangedActor, actorC, TEST_LOCATION );
5376
5377   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5378   application.SendNotification();
5379   application.Render();
5380
5381   application.ProcessEvent( touchEvent );
5382
5383   glAbstraction.ResetSetUniformCallStack();
5384   glSetUniformStack = glAbstraction.GetSetUniformTrace();
5385
5386   application.Render();
5387   tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
5388
5389   // Test order of uniforms in stack
5390   indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "3" );
5391   indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "2" );
5392   indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "1" );
5393
5394   DALI_TEST_EQUALS( indexA > indexC, true, TEST_LOCATION );
5395   DALI_TEST_EQUALS( indexB > indexA, true, TEST_LOCATION );
5396
5397   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
5398   DALI_TEST_EQUALS( gTouchCallBackCalled2, true, TEST_LOCATION );
5399   DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
5400
5401   ResetTouchCallbacks();
5402
5403   tet_printf( "Lower actor B below Actor C leaving A on top\n" );
5404
5405   orderChangedSignal = false;
5406
5407   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5408   actorB.LowerBelow( actorC );
5409   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5410   DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
5411
5412   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5413   application.SendNotification();
5414   application.Render();
5415
5416   application.ProcessEvent( touchEvent );
5417
5418   glAbstraction.ResetSetUniformCallStack();
5419   glSetUniformStack = glAbstraction.GetSetUniformTrace();
5420
5421   application.Render();
5422   tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
5423
5424   // Test order of uniforms in stack
5425   indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "3" );
5426   indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "2" );
5427   indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "1" );
5428
5429   DALI_TEST_EQUALS( indexC > indexB, true, TEST_LOCATION );
5430   DALI_TEST_EQUALS( indexA > indexC, true, TEST_LOCATION );
5431
5432   END_TEST;
5433 }
5434
5435
5436 int UtcDaliActorRaiseAboveDifferentParentsN(void)
5437 {
5438   tet_infoline( "UtcDaliActor RaiseToAbove test with actor and target actor having different parents \n" );
5439
5440   TestApplication application;
5441
5442   Stage stage( Stage::GetCurrent() );
5443
5444   Actor parentA = Actor::New();
5445   Actor parentB = Actor::New();
5446   parentA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5447   parentA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5448   parentB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5449   parentB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5450
5451   parentA.SetAnchorPoint( AnchorPoint::CENTER );
5452   parentA.SetParentOrigin( ParentOrigin::CENTER );
5453
5454   parentB.SetAnchorPoint( AnchorPoint::CENTER );
5455   parentB.SetParentOrigin( ParentOrigin::CENTER );
5456
5457   stage.Add( parentA );
5458   stage.Add( parentB );
5459
5460   Actor actorA = Actor::New();
5461   Actor actorB = Actor::New();
5462   Actor actorC = Actor::New();
5463
5464   parentA.Add( actorA );
5465   parentA.Add( actorB );
5466
5467   tet_printf( "Actor C added to different parent from A and B \n" );
5468   parentB.Add( actorC );
5469
5470   actorA.SetAnchorPoint( AnchorPoint::CENTER );
5471   actorA.SetParentOrigin( ParentOrigin::CENTER );
5472
5473   actorB.SetAnchorPoint( AnchorPoint::CENTER );
5474   actorB.SetParentOrigin( ParentOrigin::CENTER );
5475
5476   actorC.SetAnchorPoint( AnchorPoint::CENTER );
5477   actorC.SetParentOrigin( ParentOrigin::CENTER );
5478
5479   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5480   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5481
5482   actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5483   actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5484
5485   actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5486   actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5487
5488   ResetTouchCallbacks();
5489
5490   // Connect ChildOrderChangedSignal
5491   bool orderChangedSignal( false );
5492   Actor orderChangedActor;
5493   ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
5494   DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
5495
5496   application.SendNotification();
5497   application.Render();
5498
5499   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
5500   DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
5501   DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
5502
5503   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
5504   // Only top actor will get touched.
5505   actorA.TouchSignal().Connect( TestTouchCallback );
5506   actorB.TouchSignal().Connect( TestTouchCallback2 );
5507   actorC.TouchSignal().Connect( TestTouchCallback3 );
5508
5509   Dali::Integration::Point point;
5510   point.SetDeviceId( 1 );
5511   point.SetState( PointState::DOWN );
5512   point.SetScreenPosition( Vector2( 10.f, 10.f ) );
5513   Dali::Integration::TouchEvent touchEvent;
5514   touchEvent.AddPoint( point );
5515
5516   application.ProcessEvent( touchEvent );
5517
5518   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5519   DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
5520   DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
5521
5522   ResetTouchCallbacks();
5523
5524   tet_printf( "Raise actor A Above Actor C which have different parents\n" );
5525
5526   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5527   actorA.RaiseAbove( actorC );
5528   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5529
5530   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5531   application.SendNotification();
5532
5533   application.ProcessEvent( touchEvent ); // touch event
5534
5535   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5536   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5537   DALI_TEST_EQUALS( gTouchCallBackCalled3,  true , TEST_LOCATION );
5538
5539   ResetTouchCallbacks();
5540
5541   END_TEST;
5542 }
5543
5544 int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void)
5545 {
5546   tet_infoline( "UtcDaliActor Test  raiseAbove and lowerBelow api when target Actor has no parent \n" );
5547
5548   TestApplication application;
5549
5550   Stage stage( Stage::GetCurrent() );
5551
5552   Actor actorA = Actor::New();
5553   Actor actorB = Actor::New();
5554   Actor actorC = Actor::New();
5555
5556   actorA.SetAnchorPoint( AnchorPoint::CENTER );
5557   actorA.SetParentOrigin( ParentOrigin::CENTER );
5558
5559   actorB.SetAnchorPoint( AnchorPoint::CENTER );
5560   actorB.SetParentOrigin( ParentOrigin::CENTER );
5561
5562   actorC.SetAnchorPoint( AnchorPoint::CENTER );
5563   actorC.SetParentOrigin( ParentOrigin::CENTER );
5564
5565   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5566   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5567
5568   actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5569   actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5570
5571   actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5572   actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5573
5574   ResetTouchCallbacks();
5575
5576   // Connect ChildOrderChangedSignal
5577   bool orderChangedSignal( false );
5578   Actor orderChangedActor;
5579   ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
5580   DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
5581
5582   application.SendNotification();
5583   application.Render();
5584
5585   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
5586   DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
5587   DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
5588
5589   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
5590   // Only top actor will get touched.
5591   actorA.TouchSignal().Connect( TestTouchCallback );
5592   actorB.TouchSignal().Connect( TestTouchCallback2 );
5593   actorC.TouchSignal().Connect( TestTouchCallback3 );
5594
5595   Dali::Integration::Point point;
5596   point.SetDeviceId( 1 );
5597   point.SetState( PointState::DOWN );
5598   point.SetScreenPosition( Vector2( 10.f, 10.f ) );
5599   Dali::Integration::TouchEvent touchEvent;
5600   touchEvent.AddPoint( point );
5601
5602   tet_printf( "Raise actor A Above Actor C which have no parents\n" );
5603
5604   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5605   actorA.RaiseAbove( actorC );
5606   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5607
5608   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5609   application.SendNotification();
5610
5611   application.ProcessEvent( touchEvent );
5612
5613   tet_printf( "Not parented so RaiseAbove should show no effect\n" );
5614
5615   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5616   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5617   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5618
5619   ResetTouchCallbacks();
5620
5621   orderChangedSignal = false;
5622
5623   stage.Add ( actorB );
5624   tet_printf( "Lower actor A below Actor C when only A is not on stage \n" );
5625
5626   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5627   actorA.LowerBelow( actorC );
5628   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5629
5630   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5631   application.SendNotification();
5632   application.Render();
5633
5634   application.ProcessEvent( touchEvent );
5635
5636   tet_printf( "Actor A not parented so LowerBelow should show no effect\n" );
5637   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5638   DALI_TEST_EQUALS( gTouchCallBackCalled2,  true, TEST_LOCATION );
5639   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5640
5641   ResetTouchCallbacks();
5642
5643   orderChangedSignal = false;
5644
5645   tet_printf( "Adding Actor A to stage, will be on top\n" );
5646
5647   stage.Add ( actorA );
5648   application.SendNotification();
5649   application.Render();
5650
5651   tet_printf( "Raise actor B Above Actor C when only B has a parent\n" );
5652
5653   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5654   actorB.RaiseAbove( actorC );
5655   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5656
5657   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5658   application.SendNotification();
5659
5660   application.ProcessEvent( touchEvent );
5661
5662   tet_printf( "C not parented so RaiseAbove should show no effect\n" );
5663   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5664   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5665   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5666
5667   ResetTouchCallbacks();
5668
5669   orderChangedSignal = false;
5670
5671   tet_printf( "Lower actor A below Actor C when only A has a parent\n" );
5672
5673   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5674   actorA.LowerBelow( actorC );
5675   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5676
5677   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5678   application.SendNotification();
5679
5680   application.ProcessEvent( touchEvent );
5681
5682   tet_printf( "C not parented so LowerBelow should show no effect\n" );
5683   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5684   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5685   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5686
5687   ResetTouchCallbacks();
5688
5689   orderChangedSignal = false;
5690
5691   stage.Add ( actorC );
5692
5693   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5694   actorA.RaiseAbove( actorC );
5695   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5696   DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
5697
5698   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5699   application.SendNotification();
5700   application.Render();
5701
5702   application.ProcessEvent( touchEvent );
5703
5704   tet_printf( "Raise actor A Above Actor C, now both have same parent \n" );
5705   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5706   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5707   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5708
5709   END_TEST;
5710 }
5711
5712 int UtcDaliActorTestAllAPIwhenActorNotParented(void)
5713 {
5714   tet_infoline( "UtcDaliActor Test all raise/lower api when actor has no parent \n" );
5715
5716   TestApplication application;
5717
5718   Stage stage( Stage::GetCurrent() );
5719
5720   Actor actorA = Actor::New();
5721   Actor actorB = Actor::New();
5722   Actor actorC = Actor::New();
5723
5724   actorA.SetAnchorPoint( AnchorPoint::CENTER );
5725   actorA.SetParentOrigin( ParentOrigin::CENTER );
5726
5727   actorB.SetAnchorPoint( AnchorPoint::CENTER );
5728   actorB.SetParentOrigin( ParentOrigin::CENTER );
5729
5730   actorC.SetAnchorPoint( AnchorPoint::CENTER );
5731   actorC.SetParentOrigin( ParentOrigin::CENTER );
5732
5733   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5734   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5735
5736   actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5737   actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5738
5739   actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5740   actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5741
5742   ResetTouchCallbacks();
5743
5744   // Connect ChildOrderChangedSignal
5745   bool orderChangedSignal( false );
5746   Actor orderChangedActor;
5747   ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
5748   DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
5749
5750   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
5751   // Only top actor will get touched.
5752   actorA.TouchSignal().Connect( TestTouchCallback );
5753   actorB.TouchSignal().Connect( TestTouchCallback2 );
5754   actorC.TouchSignal().Connect( TestTouchCallback3 );
5755
5756   Dali::Integration::Point point;
5757   point.SetDeviceId( 1 );
5758   point.SetState( PointState::DOWN );
5759   point.SetScreenPosition( Vector2( 10.f, 10.f ) );
5760   Dali::Integration::TouchEvent touchEvent;
5761   touchEvent.AddPoint( point );
5762
5763   stage.Add ( actorA );
5764   tet_printf( "Raise actor B Above Actor C but B not parented\n" );
5765
5766   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5767   actorB.Raise();
5768   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5769
5770   application.SendNotification();
5771   application.Render();
5772
5773   application.ProcessEvent( touchEvent );
5774
5775   tet_printf( "Not parented so RaiseAbove should show no effect\n" );
5776
5777   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5778   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5779   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5780
5781   tet_printf( "Raise actor B Above Actor C but B not parented\n" );
5782   ResetTouchCallbacks();
5783
5784   orderChangedSignal = false;
5785
5786   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5787   actorC.Lower();
5788   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5789
5790   // Sort actor tree before next touch event
5791   application.SendNotification();
5792   application.Render();
5793
5794   application.ProcessEvent( touchEvent );
5795
5796   tet_printf( "Not parented so RaiseAbove should show no effect\n" );
5797
5798   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5799   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5800   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5801   ResetTouchCallbacks();
5802
5803   orderChangedSignal = false;
5804
5805   tet_printf( "Lower actor C below B but C not parented\n" );
5806
5807   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5808   actorB.Lower();
5809   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5810
5811   // Sort actor tree before next touch event
5812   application.SendNotification();
5813   application.Render();
5814
5815   application.ProcessEvent( touchEvent );
5816
5817   tet_printf( "Not parented so Lower should show no effect\n" );
5818
5819   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5820   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5821   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5822   ResetTouchCallbacks();
5823
5824   orderChangedSignal = false;
5825
5826   tet_printf( "Raise actor B to top\n" );
5827
5828   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5829   actorB.RaiseToTop();
5830   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5831
5832   // Sort actor tree before next touch event
5833   application.SendNotification();
5834   application.Render();
5835
5836   application.ProcessEvent( touchEvent );
5837
5838   tet_printf( "Not parented so RaiseToTop should show no effect\n" );
5839
5840   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5841   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5842   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5843   ResetTouchCallbacks();
5844
5845   orderChangedSignal = false;
5846
5847   tet_printf( "Add ActorB to stage so only Actor C not parented\n" );
5848
5849   stage.Add ( actorB );
5850
5851   tet_printf( "Lower actor C to Bottom, B stays at top\n" );
5852
5853   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5854   actorC.LowerToBottom();
5855   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5856
5857   application.SendNotification();
5858   application.Render();
5859
5860   application.ProcessEvent( touchEvent );
5861
5862   tet_printf( "Not parented so LowerToBottom should show no effect\n" );
5863
5864   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5865   DALI_TEST_EQUALS( gTouchCallBackCalled2,  true, TEST_LOCATION );
5866   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5867   ResetTouchCallbacks();
5868
5869   END_TEST;
5870 }
5871
5872
5873 int UtcDaliActorRaiseAboveActorAndTargetTheSameN(void)
5874 {
5875   tet_infoline( "UtcDaliActor RaiseToAbove and  test with actor provided as target resulting in a no operation \n" );
5876
5877   TestApplication application;
5878
5879   Stage stage( Stage::GetCurrent() );
5880
5881   Actor actorA = Actor::New();
5882   Actor actorB = Actor::New();
5883   Actor actorC = Actor::New();
5884
5885   actorA.SetAnchorPoint( AnchorPoint::CENTER );
5886   actorA.SetParentOrigin( ParentOrigin::CENTER );
5887
5888   actorB.SetAnchorPoint( AnchorPoint::CENTER );
5889   actorB.SetParentOrigin( ParentOrigin::CENTER );
5890
5891   actorC.SetAnchorPoint( AnchorPoint::CENTER );
5892   actorC.SetParentOrigin( ParentOrigin::CENTER );
5893
5894   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5895   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5896
5897   actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5898   actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5899
5900   actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5901   actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5902
5903   stage.Add( actorA );
5904   stage.Add( actorB );
5905   stage.Add( actorC );
5906
5907   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
5908   // Only top actor will get touched.
5909   actorA.TouchSignal().Connect( TestTouchCallback );
5910   actorB.TouchSignal().Connect( TestTouchCallback2 );
5911   actorC.TouchSignal().Connect( TestTouchCallback3 );
5912
5913   ResetTouchCallbacks();
5914
5915   // Connect ChildOrderChangedSignal
5916   bool orderChangedSignal( false );
5917   Actor orderChangedActor;
5918   ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
5919   DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
5920
5921   application.SendNotification();
5922   application.Render();
5923
5924   Dali::Integration::Point point;
5925   point.SetDeviceId( 1 );
5926   point.SetState( PointState::DOWN );
5927   point.SetScreenPosition( Vector2( 10.f, 10.f ) );
5928   Dali::Integration::TouchEvent touchEvent;
5929   touchEvent.AddPoint( point );
5930
5931   application.ProcessEvent( touchEvent );
5932
5933   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
5934   DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
5935   DALI_TEST_EQUALS( gTouchCallBackCalled3, true, TEST_LOCATION );
5936
5937   ResetTouchCallbacks();
5938
5939   tet_infoline( "Raise actor A Above Actor A which is the same actor!!\n" );
5940
5941   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5942   actorA.RaiseAbove( actorA );
5943   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5944   DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
5945
5946   application.SendNotification();
5947   application.Render();
5948
5949   application.ProcessEvent( touchEvent );
5950
5951   tet_infoline( "No target is source Actor so RaiseAbove should show no effect\n" );
5952
5953   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5954   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5955   DALI_TEST_EQUALS( gTouchCallBackCalled3,  true , TEST_LOCATION );
5956
5957   ResetTouchCallbacks();
5958
5959   orderChangedSignal = false;
5960
5961   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5962   actorA.RaiseAbove( actorC );
5963   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5964   DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
5965
5966   application.SendNotification();
5967   application.Render();
5968
5969   application.ProcessEvent( touchEvent );
5970
5971   tet_infoline( "Raise actor A Above Actor C which will now be successful \n" );
5972   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5973   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5974   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5975
5976   END_TEST;
5977 }
5978
5979 int UtcDaliActorGetScreenPosition(void)
5980 {
5981   tet_infoline( "UtcDaliActorGetScreenPosition Get screen coordinates of Actor \n" );
5982
5983   TestApplication application;
5984
5985   Stage stage( Stage::GetCurrent() );
5986
5987   Actor actorA = Actor::New();
5988   actorA.SetAnchorPoint( AnchorPoint::CENTER );
5989
5990   Vector2 size2( 10.0f, 20.0f );
5991   actorA.SetSize( size2 );
5992
5993   actorA.SetPosition( 0.f, 0.f );
5994
5995   tet_infoline( "UtcDaliActorGetScreenPosition Center Anchor Point and 0,0 position \n" );
5996
5997   stage.Add( actorA );
5998
5999   application.SendNotification();
6000   application.Render();
6001
6002   Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6003   Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6004
6005   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::CENTER \n",  actorWorldPosition.x, actorWorldPosition.y  );
6006   tet_printf( "Actor Screen Position %f %f \n", actorScreenPosition.x, actorScreenPosition.y );
6007
6008   DALI_TEST_EQUALS( actorScreenPosition.x,  0lu , TEST_LOCATION );
6009   DALI_TEST_EQUALS( actorScreenPosition.y,  0lu , TEST_LOCATION );
6010
6011   tet_infoline( "UtcDaliActorGetScreenPosition Top Left Anchor Point and 0,0 position \n" );
6012
6013   actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6014
6015   application.SendNotification();
6016   application.Render();
6017
6018   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6019   actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6020
6021   tet_printf( "Actor World Position  ( %f %f ) AnchorPoint::TOP_LEFT  \n",  actorWorldPosition.x, actorWorldPosition.y );
6022   tet_printf( "Actor Screen Position  ( %f %f ) AnchorPoint::TOP_LEFT \n", actorScreenPosition.x, actorScreenPosition.y );
6023
6024   DALI_TEST_EQUALS( actorScreenPosition.x,  0lu , TEST_LOCATION );
6025   DALI_TEST_EQUALS( actorScreenPosition.y,  0lu , TEST_LOCATION );
6026
6027   tet_infoline( "UtcDaliActorGetScreenPosition Bottom right Anchor Point and 0,0 position \n" );
6028
6029   actorA.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
6030
6031   application.SendNotification();
6032   application.Render();
6033
6034   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6035   actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6036
6037   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT   \n",  actorWorldPosition.x, actorWorldPosition.y );
6038   tet_printf( "Actor Screen Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT  \n", actorScreenPosition.x, actorScreenPosition.y );
6039
6040   DALI_TEST_EQUALS( actorScreenPosition.x,  0lu , TEST_LOCATION );
6041   DALI_TEST_EQUALS( actorScreenPosition.y,  0lu , TEST_LOCATION );
6042
6043   tet_infoline( "UtcDaliActorGetScreenPosition Bottom right Anchor Point and 30,0 position \n" );
6044
6045   actorA.SetPosition( 30.0, 0.0 );
6046
6047   application.SendNotification();
6048   application.Render();
6049
6050   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6051   actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6052
6053   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 0.0 \n",  actorWorldPosition.x, actorWorldPosition.y );
6054   tet_printf( "Actor Screen Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 0.0   \n", actorScreenPosition.x, actorScreenPosition.y );
6055
6056   DALI_TEST_EQUALS( actorScreenPosition.x,  30lu , TEST_LOCATION );
6057   DALI_TEST_EQUALS( actorScreenPosition.y,  0lu , TEST_LOCATION );
6058
6059   tet_infoline( "UtcDaliActorGetScreenPosition Bottom right Anchor Point and 30,420 position \n" );
6060
6061   actorA.SetPosition( 30.0, 420.0 );
6062
6063   application.SendNotification();
6064   application.Render();
6065
6066   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6067   actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6068
6069   DALI_TEST_EQUALS( actorScreenPosition.x,  30lu , TEST_LOCATION );
6070   DALI_TEST_EQUALS( actorScreenPosition.y,  420lu , TEST_LOCATION );
6071
6072   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 420.0\n",  actorWorldPosition.x, actorWorldPosition.y );
6073   tet_printf( "Actor Screen Position( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 420.0 \n", actorScreenPosition.x, actorScreenPosition.y );
6074
6075   tet_infoline( "UtcDaliActorGetScreenPosition Scale parent and check child's screen position \n" );
6076
6077   actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6078   actorA.SetPosition( 30.0, 30.0 );
6079
6080   Actor actorB = Actor::New();
6081   actorB.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6082   actorB.SetSize( size2 );
6083   actorB.SetPosition( 10.f, 10.f );
6084   actorA.Add( actorB );
6085
6086   actorA.SetScale( 2.0f );
6087
6088   application.SendNotification();
6089   application.Render();
6090
6091   actorScreenPosition = actorB.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6092
6093   DALI_TEST_EQUALS( actorScreenPosition.x,  50lu , TEST_LOCATION );
6094   DALI_TEST_EQUALS( actorScreenPosition.y,  50lu , TEST_LOCATION );
6095
6096   END_TEST;
6097 }
6098
6099 int UtcDaliActorGetScreenPositionAfterScaling(void)
6100 {
6101   tet_infoline( "UtcDaliActorGetScreenPositionAfterScaling Get screen coordinates of Actor \n" );
6102
6103   TestApplication application;
6104
6105   Stage stage( Stage::GetCurrent() );
6106
6107   Actor actorA = Actor::New();
6108   actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6109
6110   Vector2 size2( 10.0f, 20.0f );
6111   actorA.SetSize( size2 );
6112   actorA.SetScale( 1.5f );
6113   actorA.SetPosition( 0.f, 0.f );
6114
6115   tet_infoline( "UtcDaliActorGetScreenPositionAfterScaling TopRight Anchor Point, scale 1.5f and 0,0 position \n" );
6116
6117   stage.Add( actorA );
6118
6119   application.SendNotification();
6120   application.Render();
6121
6122   Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6123   Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6124
6125   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT \n",  actorWorldPosition.x, actorWorldPosition.y  );
6126   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
6127
6128   DALI_TEST_EQUALS( actorScreenPosition.x,  0lu , TEST_LOCATION );
6129   DALI_TEST_EQUALS( actorScreenPosition.y,  0lu , TEST_LOCATION );
6130
6131   tet_infoline( "UtcDaliActorGetScreenPositionAfterScaling BOTTOM_RIGHT Anchor Point, scale 1.5f and 0,0 position \n" );
6132
6133   actorA.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
6134
6135   application.SendNotification();
6136   application.Render();
6137
6138   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6139   actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6140
6141   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT \n",  actorWorldPosition.x, actorWorldPosition.y  );
6142   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
6143
6144   DALI_TEST_EQUALS( actorScreenPosition.x , 0.0f  , TEST_LOCATION );
6145   DALI_TEST_EQUALS( actorScreenPosition.y,  0.0f , TEST_LOCATION );
6146
6147   END_TEST;
6148 }
6149
6150 int UtcDaliActorGetScreenPositionWithDifferentParentOrigin(void)
6151 {
6152   tet_infoline( "UtcDaliActorGetScreenPositionWithDifferentParentOrigin Changes parent origin which should not effect result \n" );
6153
6154   TestApplication application;
6155
6156   Stage stage( Stage::GetCurrent() );
6157
6158   Actor actorA = Actor::New();
6159   actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6160   actorA.SetParentOrigin( ParentOrigin::CENTER );
6161   Vector2 size2( 10.0f, 20.0f );
6162   actorA.SetSize( size2 );
6163   actorA.SetPosition( 0.f, 0.f );
6164
6165   tet_infoline( " TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
6166
6167   stage.Add( actorA );
6168
6169   application.SendNotification();
6170   application.Render();
6171
6172   Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6173   Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6174
6175   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER  \n",  actorWorldPosition.x, actorWorldPosition.y  );
6176   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
6177
6178   DALI_TEST_EQUALS( actorScreenPosition.x,  240.0f , TEST_LOCATION );
6179   DALI_TEST_EQUALS( actorScreenPosition.y,  400.0f , TEST_LOCATION );
6180
6181   tet_infoline( " BOTTOM_RIGHT Anchor Point, ParentOrigin::TOP_RIGHT and 0,0 position \n" );
6182
6183   actorA.SetParentOrigin( ParentOrigin::TOP_RIGHT );
6184   actorA.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
6185
6186   application.SendNotification();
6187   application.Render();
6188
6189   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6190   actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6191
6192   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT ParentOrigin::TOP_RIGHT \n",  actorWorldPosition.x, actorWorldPosition.y  );
6193   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
6194
6195   DALI_TEST_EQUALS( actorScreenPosition.x , 480.0f , TEST_LOCATION );
6196   DALI_TEST_EQUALS( actorScreenPosition.y,  0.0f , TEST_LOCATION );
6197
6198   END_TEST;
6199   END_TEST;
6200 }
6201
6202 int UtcDaliActorGetScreenPositionWithChildActors(void)
6203 {
6204   tet_infoline( "UtcDaliActorGetScreenPositionWithChildActors Check screen position with a tree of actors \n" );
6205
6206   TestApplication application;
6207
6208   Stage stage( Stage::GetCurrent() );
6209
6210   tet_infoline( "Create Child Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
6211
6212   Actor actorA = Actor::New();
6213   actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6214   actorA.SetParentOrigin( ParentOrigin::CENTER );
6215   Vector2 size1( 10.0f, 20.0f );
6216   actorA.SetSize( size1 );
6217   actorA.SetPosition( 0.f, 0.f );
6218
6219   tet_infoline( "Create Parent Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
6220
6221   Actor parentActorA = Actor::New();
6222   parentActorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6223   parentActorA.SetParentOrigin( ParentOrigin::CENTER );
6224   Vector2 size2( 30.0f, 60.0f );
6225   parentActorA.SetSize( size2 );
6226   parentActorA.SetPosition( 0.f, 0.f );
6227
6228   tet_infoline( "Add child 1 to Parent 1 and check screen position \n" );
6229
6230   stage.Add( parentActorA );
6231   parentActorA.Add ( actorA );
6232
6233   application.SendNotification();
6234   application.Render();
6235
6236   Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6237   Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6238
6239   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER  \n",  actorWorldPosition.x, actorWorldPosition.y  );
6240   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
6241
6242   DALI_TEST_EQUALS( actorScreenPosition.x,  255.0f , TEST_LOCATION );
6243   DALI_TEST_EQUALS( actorScreenPosition.y,  430.0f , TEST_LOCATION );
6244
6245   tet_infoline( "Test 2\n");
6246
6247   tet_infoline( "change parent anchor point and parent origin then check screen position \n" );
6248
6249   parentActorA.SetAnchorPoint( AnchorPoint::BOTTOM_LEFT );
6250   parentActorA.SetParentOrigin( ParentOrigin::TOP_LEFT );
6251
6252   application.SendNotification();
6253   application.Render();
6254
6255   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6256   actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6257
6258   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_LEFT ParentOrigin::TOP_LEFT  \n",  actorWorldPosition.x, actorWorldPosition.y  );
6259   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
6260
6261   DALI_TEST_EQUALS( actorScreenPosition.x,  15.0f , TEST_LOCATION );
6262   DALI_TEST_EQUALS( actorScreenPosition.y,  -30.0f , TEST_LOCATION );
6263
6264   END_TEST;
6265 }
6266
6267 int UtcDaliActorGetScreenPositionWithChildActors02(void)
6268 {
6269   tet_infoline( "UtcDaliActorGetScreenPositionWithChildActors02 Check screen position with a tree of actors \n" );
6270
6271   TestApplication application;
6272
6273   Stage stage( Stage::GetCurrent() );
6274
6275   tet_infoline( "Create Child Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
6276
6277   Actor actorA = Actor::New();
6278   actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6279   actorA.SetParentOrigin( ParentOrigin::CENTER );
6280   Vector2 size1( 10.0f, 20.0f );
6281   actorA.SetSize( size1 );
6282   actorA.SetPosition( 0.f, 0.f );
6283
6284   tet_infoline( "Create Parent Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
6285
6286   Actor parentActorA = Actor::New();
6287   parentActorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6288   parentActorA.SetParentOrigin( ParentOrigin::CENTER );
6289   Vector2 size2( 30.0f, 60.0f );
6290   parentActorA.SetSize( size2 );
6291   parentActorA.SetPosition( 0.f, 0.f );
6292
6293   tet_infoline( "Create Grand Parent Actor 1 BOTTOM_LEFT Anchor Point, ParentOrigin::BOTTOM_LEFT and 0,0 position \n" );
6294
6295   Actor grandParentActorA = Actor::New();
6296   grandParentActorA.SetAnchorPoint( AnchorPoint::BOTTOM_LEFT );
6297   grandParentActorA.SetParentOrigin( ParentOrigin::BOTTOM_LEFT );
6298   Vector2 size3( 60.0f, 120.0f );
6299   grandParentActorA.SetSize( size3 );
6300   grandParentActorA.SetPosition( 0.f, 0.f );
6301
6302   tet_infoline( "Add Parent 1 to Grand Parent 1 \n" );
6303
6304   stage.Add( grandParentActorA );
6305   grandParentActorA.Add ( parentActorA );
6306
6307   tet_infoline( "Add child 1 to Parent 1 and check screen position \n" );
6308
6309   parentActorA.Add ( actorA );
6310
6311   application.SendNotification();
6312   application.Render();
6313
6314   Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6315   Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6316
6317   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER  \n",  actorWorldPosition.x, actorWorldPosition.y  );
6318   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
6319
6320   DALI_TEST_EQUALS( actorScreenPosition.x,  45.0f , TEST_LOCATION );
6321   DALI_TEST_EQUALS( actorScreenPosition.y,  770.0f , TEST_LOCATION );
6322
6323   END_TEST;
6324 }
6325
6326 int UtcDaliActorGetScreenPositionPositionUsesAnchorPointFalse(void)
6327 {
6328   tet_infoline( "UtcDaliActorGetScreenPositionPositionUsesAnchorPointFalse Check screen position where the position does not use the anchor point" );
6329
6330   TestApplication application;
6331
6332   Stage stage( Stage::GetCurrent() );
6333
6334   tet_infoline( "Create an actor with AnchorPoint::TOP_LEFT, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false" );
6335
6336   Actor actorA = Actor::New();
6337   actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6338   actorA.SetParentOrigin( ParentOrigin::CENTER );
6339   actorA.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
6340   actorA.SetSize( 10.0f, 20.0f );
6341   stage.Add( actorA );
6342
6343   tet_infoline( "Create an Actor with AnchorPoint::BOTTOM_RIGHT, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false" );
6344
6345   Actor actorB = Actor::New();
6346   actorB.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
6347   actorB.SetParentOrigin( ParentOrigin::CENTER );
6348   actorB.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
6349   Vector2 actorBSize( 30.0f, 60.0f );
6350   actorB.SetSize( actorBSize );
6351   stage.Add( actorB );
6352
6353   tet_infoline( "Create an actor with AnchorPoint::CENTER, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false" );
6354
6355   Actor actorC = Actor::New();
6356   actorC.SetAnchorPoint( AnchorPoint::CENTER );
6357   actorC.SetParentOrigin( ParentOrigin::CENTER );
6358   actorC.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
6359   Vector2 actorCSize( 60.0f, 120.0f );
6360   actorC.SetSize( actorCSize );
6361   stage.Add( actorC );
6362
6363   application.SendNotification();
6364   application.Render();
6365
6366   tet_infoline( "Despite differing sizes and anchor-points, the screen position for all actors is the same");
6367
6368   Vector2 center( stage.GetSize() * 0.5f );
6369
6370   DALI_TEST_EQUALS( actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center, TEST_LOCATION );
6371   DALI_TEST_EQUALS( actorB.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center, TEST_LOCATION );
6372   DALI_TEST_EQUALS( actorC.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center, TEST_LOCATION );
6373
6374   tet_infoline( "Add scale to all actors" );
6375
6376   actorA.SetScale( 2.0f );
6377   actorB.SetScale( 2.0f );
6378   actorC.SetScale( 2.0f );
6379
6380   application.SendNotification();
6381   application.Render();
6382
6383   DALI_TEST_EQUALS( actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center /* TOP_LEFT Anchor */, TEST_LOCATION );
6384   DALI_TEST_EQUALS( actorB.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center - actorBSize /* BOTTOM_RIGHT Anchor */, TEST_LOCATION );
6385   DALI_TEST_EQUALS( actorC.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center - actorCSize * 0.5f /* CENTER Anchor*/, TEST_LOCATION );
6386
6387   END_TEST;
6388 }
6389
6390 int utcDaliActorPositionUsesAnchorPoint(void)
6391 {
6392   TestApplication application;
6393   tet_infoline( "Check default behaviour\n" );
6394
6395   Actor actor = Actor::New();
6396   actor.SetParentOrigin( ParentOrigin::CENTER );
6397   actor.SetAnchorPoint( AnchorPoint::CENTER );
6398   actor.SetSize( 100.0f, 100.0f );
6399   Stage::GetCurrent().Add( actor );
6400
6401   application.SendNotification();
6402   application.Render();
6403
6404   tet_infoline( "Check that the world position is in the center\n" );
6405   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
6406
6407   tet_infoline( "Set the position uses anchor point property to false\n" );
6408   actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
6409
6410   application.SendNotification();
6411   application.Render();
6412
6413   tet_infoline( "Check that the world position has changed appropriately\n" );
6414   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
6415
6416   END_TEST;
6417 }
6418
6419 int utcDaliActorPositionUsesAnchorPointCheckScale(void)
6420 {
6421   TestApplication application;
6422   tet_infoline( "Check that the scale is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
6423
6424   Actor actor = Actor::New();
6425   actor.SetParentOrigin( ParentOrigin::CENTER );
6426   actor.SetAnchorPoint( AnchorPoint::CENTER );
6427   actor.SetSize( 100.0f, 100.0f );
6428   actor.SetScale( 2.0f );
6429   actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
6430   Stage::GetCurrent().Add( actor );
6431
6432   application.SendNotification();
6433   application.Render();
6434
6435   tet_infoline( "Check the world position is the same as it would be without a scale\n" );
6436   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
6437
6438   tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly" );
6439   actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6440   application.SendNotification();
6441   application.Render();
6442   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 100.0f, 100.0f, 0.0f ), TEST_LOCATION );
6443
6444   tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly" );
6445   actor.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
6446   application.SendNotification();
6447   application.Render();
6448   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
6449
6450   END_TEST;
6451 }
6452
6453 int utcDaliActorPositionUsesAnchorPointCheckRotation(void)
6454 {
6455   TestApplication application;
6456   tet_infoline( "Check that the rotation is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
6457
6458   Actor actor = Actor::New();
6459   actor.SetParentOrigin( ParentOrigin::CENTER );
6460   actor.SetAnchorPoint( AnchorPoint::CENTER );
6461   actor.SetSize( 100.0f, 100.0f );
6462   actor.SetOrientation( Degree( 90.0f), Vector3::ZAXIS );
6463   actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
6464   Stage::GetCurrent().Add( actor );
6465
6466   application.SendNotification();
6467   application.Render();
6468
6469   tet_infoline( "Check the world position is the same as it would be without a rotation\n" );
6470   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
6471
6472   tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly" );
6473   actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6474   application.SendNotification();
6475   application.Render();
6476   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( -50.0f, 50.0f, 0.0f ), TEST_LOCATION );
6477
6478   tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly" );
6479   actor.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
6480   application.SendNotification();
6481   application.Render();
6482   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 150.0f, 50.0f, 0.0f ), TEST_LOCATION );
6483
6484   END_TEST;
6485 }
6486
6487 int utcDaliActorPositionUsesAnchorPointCheckScaleAndRotation(void)
6488 {
6489   TestApplication application;
6490   tet_infoline( "Check that the scale and rotation is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
6491
6492   Actor actor = Actor::New();
6493   actor.SetParentOrigin( ParentOrigin::CENTER );
6494   actor.SetAnchorPoint( AnchorPoint::CENTER );
6495   actor.SetSize( 100.0f, 100.0f );
6496   actor.SetOrientation( Degree( 90.0f), Vector3::ZAXIS );
6497   actor.SetScale( 2.0f );
6498   actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
6499   Stage::GetCurrent().Add( actor );
6500
6501   application.SendNotification();
6502   application.Render();
6503
6504   tet_infoline( "Check the world position is the same as it would be without a scale and rotation\n" );
6505   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
6506
6507   tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly" );
6508   actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6509   application.SendNotification();
6510   application.Render();
6511   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( -100.0f, 100.0f, 0.0f ), TEST_LOCATION );
6512
6513   tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly" );
6514   actor.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
6515   application.SendNotification();
6516   application.Render();
6517   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 200.0f, 0.0f, 0.0f ), TEST_LOCATION );
6518
6519   END_TEST;
6520 }
6521
6522 int utcDaliActorPositionUsesAnchorPointOnlyInheritPosition(void)
6523 {
6524   TestApplication application;
6525   tet_infoline( "Check that if not inheriting scale and position, then the position is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
6526
6527   Actor parent = Actor::New();
6528
6529   Stage::GetCurrent().Add( parent );
6530   Vector2 stageSize( Stage::GetCurrent().GetSize() );
6531
6532   Actor actor = Actor::New();
6533   actor.SetParentOrigin( ParentOrigin::CENTER );
6534   actor.SetAnchorPoint( AnchorPoint::CENTER );
6535   actor.SetSize( 100.0f, 100.0f );
6536   actor.SetInheritScale( false );
6537   actor.SetInheritOrientation( false );
6538   actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
6539   parent.Add( actor );
6540
6541   application.SendNotification();
6542   application.Render();
6543
6544   const Vector3 expectedWorldPosition( -stageSize.width * 0.5f + 50.0f, -stageSize.height * 0.5f + 50.0f, 0.0f );
6545
6546   tet_infoline( "Check the world position is in the right place\n" );
6547   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), expectedWorldPosition, TEST_LOCATION );
6548
6549   tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure world position hasn't changed" );
6550   actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6551   application.SendNotification();
6552   application.Render();
6553   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), expectedWorldPosition, TEST_LOCATION );
6554
6555   tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure world position hasn't changed" );
6556   actor.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
6557   application.SendNotification();
6558   application.Render();
6559   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), expectedWorldPosition, TEST_LOCATION );
6560
6561   END_TEST;
6562 }
6563
6564 int utcDaliActorVisibilityChangeSignalSelf(void)
6565 {
6566   TestApplication application;
6567   tet_infoline( "Check that the visibility change signal is called when the visibility changes for the actor itself" );
6568
6569   Actor actor = Actor::New();
6570
6571   VisibilityChangedFunctorData data;
6572   DevelActor::VisibilityChangedSignal( actor ).Connect( &application, VisibilityChangedFunctor( data ) );
6573
6574   actor.SetVisible( false );
6575
6576   data.Check( true /* called */, actor, false /* not visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION );
6577
6578   tet_infoline( "Ensure functor is not called if we attempt to change the visibility to what it already is at" );
6579   data.Reset();
6580
6581   actor.SetVisible( false );
6582   data.Check( false /* not called */, TEST_LOCATION );
6583
6584   tet_infoline( "Change the visibility using properties, ensure called" );
6585   data.Reset();
6586
6587   actor.SetProperty( Actor::Property::VISIBLE, true );
6588   data.Check( true /* called */, actor, true /* visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION );
6589
6590   tet_infoline( "Set the visibility to current using properties, ensure not called" );
6591   data.Reset();
6592
6593   actor.SetProperty( Actor::Property::VISIBLE, true );
6594   data.Check( false /* not called */, TEST_LOCATION );
6595
6596   END_TEST;
6597 }
6598
6599 int utcDaliActorVisibilityChangeSignalChildren(void)
6600 {
6601   TestApplication application;
6602   tet_infoline( "Check that the visibility change signal is called for the children when the visibility changes for the parent" );
6603
6604   Actor parent = Actor::New();
6605   Actor child = Actor::New();
6606   parent.Add( child );
6607
6608   Actor grandChild = Actor::New();
6609   child.Add( grandChild );
6610
6611   VisibilityChangedFunctorData parentData;
6612   VisibilityChangedFunctorData childData;
6613   VisibilityChangedFunctorData grandChildData;
6614
6615   tet_infoline( "Only connect the child and grandchild, ensure they are called and not the parent" );
6616   DevelActor::VisibilityChangedSignal( child ).Connect( &application, VisibilityChangedFunctor( childData ) );
6617   DevelActor::VisibilityChangedSignal( grandChild ).Connect( &application, VisibilityChangedFunctor( grandChildData ) );
6618
6619   parent.SetVisible( false );
6620   parentData.Check( false /* not called */, TEST_LOCATION );
6621   childData.Check( true /* called */, child, false /* not visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION );
6622   grandChildData.Check( true /* called */, grandChild, false /* not visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION );
6623
6624   tet_infoline( "Connect to the parent's signal as well and ensure all three are called" );
6625   parentData.Reset();
6626   childData.Reset();
6627   grandChildData.Reset();
6628
6629   DevelActor::VisibilityChangedSignal( parent ).Connect( &application, VisibilityChangedFunctor( parentData ) );
6630
6631   parent.SetVisible( true );
6632   parentData.Check( true /* called */, parent, true /* visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION );
6633   childData.Check( true /* called */, child, true /* visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION );
6634   grandChildData.Check( true /* called */, grandChild, true /* visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION );
6635
6636   tet_infoline( "Ensure none of the functors are called if we attempt to change the visibility to what it already is at" );
6637   parentData.Reset();
6638   childData.Reset();
6639   grandChildData.Reset();
6640
6641   parent.SetVisible( true );
6642   parentData.Check( false /* not called */, TEST_LOCATION );
6643   childData.Check( false /* not called */, TEST_LOCATION );
6644   grandChildData.Check( false /* not called */, TEST_LOCATION );
6645
6646   END_TEST;
6647 }
6648
6649 int utcDaliActorVisibilityChangeSignalAfterAnimation(void)
6650 {
6651   TestApplication application;
6652   tet_infoline( "Check that the visibility change signal is emitted when the visibility changes when an animation starts" );
6653
6654   Actor actor = Actor::New();
6655   Stage::GetCurrent().Add( actor );
6656
6657   application.SendNotification();
6658   application.Render();
6659
6660   VisibilityChangedFunctorData data;
6661   DevelActor::VisibilityChangedSignal( actor ).Connect( &application, VisibilityChangedFunctor( data ) );
6662
6663   Animation animation = Animation::New( 1.0f );
6664   animation.AnimateTo( Property( actor, Actor::Property::VISIBLE ), false );
6665
6666   data.Check( false, TEST_LOCATION );
6667   DALI_TEST_EQUALS( actor.GetProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION );
6668   DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION );
6669
6670   tet_infoline( "Play the animation and check the property value" );
6671   animation.Play();
6672
6673   data.Check( true /* called */, actor, false /* not visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION );
6674   DALI_TEST_EQUALS( actor.GetProperty< bool >( Actor::Property::VISIBLE ), false, TEST_LOCATION );
6675
6676   tet_infoline( "Animation not currently finished, so the current visibility should still be true" );
6677   DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION );
6678
6679   application.SendNotification();
6680   application.Render( 1100 ); // After the animation
6681
6682   DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), false, TEST_LOCATION );
6683
6684   END_TEST;
6685 }
6686
6687
6688 int utcDaliActorVisibilityChangeSignalByName(void)
6689 {
6690   TestApplication application;
6691   tet_infoline( "Check that the visibility change signal is called when the visibility changes for the actor itself" );
6692
6693   Actor actor = Actor::New();
6694
6695   bool signalCalled=false;
6696   actor.ConnectSignal( &application, "visibilityChanged", VisibilityChangedVoidFunctor(signalCalled) );
6697   DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
6698   actor.SetVisible( false );
6699   DALI_TEST_EQUALS( signalCalled, true, TEST_LOCATION );
6700
6701   tet_infoline( "Ensure functor is not called if we attempt to change the visibility to what it already is at" );
6702   signalCalled = false;
6703   actor.SetVisible( false );
6704   DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
6705
6706   tet_infoline( "Change the visibility using properties, ensure called" );
6707   actor.SetProperty( Actor::Property::VISIBLE, true );
6708   DALI_TEST_EQUALS( signalCalled, true, TEST_LOCATION );
6709
6710   tet_infoline( "Set the visibility to current using properties, ensure not called" );
6711   signalCalled = false;
6712
6713   actor.SetProperty( Actor::Property::VISIBLE, true );
6714   DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
6715
6716   END_TEST;
6717 }
6718
6719
6720 static void LayoutDirectionChanged( Actor actor, LayoutDirection::Type type )
6721 {
6722   gLayoutDirectionType = type;
6723 }
6724
6725 int UtcDaliActorLayoutDirectionProperty(void)
6726 {
6727   TestApplication application;
6728   tet_infoline( "Check layout direction property" );
6729
6730   Actor actor0 = Actor::New();
6731   DALI_TEST_EQUALS( actor0.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6732   Stage::GetCurrent().Add( actor0 );
6733
6734   application.SendNotification();
6735   application.Render();
6736
6737   Actor actor1 = Actor::New();
6738   DALI_TEST_EQUALS( actor1.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6739   Actor actor2 = Actor::New();
6740   DALI_TEST_EQUALS( actor2.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6741   Actor actor3 = Actor::New();
6742   DALI_TEST_EQUALS( actor3.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6743   Actor actor4 = Actor::New();
6744   DALI_TEST_EQUALS( actor4.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6745   Actor actor5 = Actor::New();
6746   DALI_TEST_EQUALS( actor5.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6747   Actor actor6 = Actor::New();
6748   DALI_TEST_EQUALS( actor6.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6749   Actor actor7 = Actor::New();
6750   DALI_TEST_EQUALS( actor7.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6751   Actor actor8 = Actor::New();
6752   DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6753   Actor actor9 = Actor::New();
6754   DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6755
6756   actor1.Add( actor2 );
6757   gLayoutDirectionType = LayoutDirection::LEFT_TO_RIGHT;
6758   actor2.LayoutDirectionChangedSignal().Connect( LayoutDirectionChanged );
6759
6760   DALI_TEST_EQUALS( actor1.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), true, TEST_LOCATION );
6761   actor1.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT );
6762   DALI_TEST_EQUALS( actor1.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), false, TEST_LOCATION );
6763
6764   DALI_TEST_EQUALS( actor1.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
6765   DALI_TEST_EQUALS( actor2.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
6766   DALI_TEST_EQUALS( gLayoutDirectionType, LayoutDirection::RIGHT_TO_LEFT, TEST_LOCATION );
6767
6768   actor1.SetProperty( Actor::Property::INHERIT_LAYOUT_DIRECTION, true );
6769   actor0.Add( actor1 );
6770   DALI_TEST_EQUALS( actor1.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6771   DALI_TEST_EQUALS( actor2.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6772
6773   Stage::GetCurrent().Add( actor3 );
6774   actor3.Add( actor4 );
6775   actor4.Add( actor5 );
6776   actor5.Add( actor6 );
6777   actor5.Add( actor7 );
6778   actor7.Add( actor8 );
6779   actor8.Add( actor9 );
6780   actor3.SetProperty( Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT" );
6781   actor5.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT );
6782
6783   DALI_TEST_EQUALS( actor8.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), true, TEST_LOCATION );
6784   actor8.SetProperty( Actor::Property::INHERIT_LAYOUT_DIRECTION, false );
6785   DALI_TEST_EQUALS( actor8.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), false, TEST_LOCATION );
6786
6787   actor7.SetProperty( Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT" );
6788
6789   DALI_TEST_EQUALS( actor3.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
6790   DALI_TEST_EQUALS( actor4.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
6791   DALI_TEST_EQUALS( actor5.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6792   DALI_TEST_EQUALS( actor6.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6793   DALI_TEST_EQUALS( actor7.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
6794   DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6795   DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6796
6797   actor8.SetProperty( Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT" );
6798   DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
6799   DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
6800
6801   actor7.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT );
6802   DALI_TEST_EQUALS( actor7.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6803   DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
6804   DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
6805
6806   actor8.SetProperty( Actor::Property::INHERIT_LAYOUT_DIRECTION, true );
6807   DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6808   DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6809
6810   END_TEST;
6811 }
6812
6813
6814 struct LayoutDirectionFunctor
6815 {
6816   LayoutDirectionFunctor(bool& signalCalled)
6817   : mSignalCalled( signalCalled )
6818   {
6819   }
6820
6821   LayoutDirectionFunctor(const LayoutDirectionFunctor& rhs)
6822   : mSignalCalled( rhs.mSignalCalled )
6823   {
6824   }
6825
6826   void operator()()
6827   {
6828     mSignalCalled = true;
6829   }
6830
6831   bool& mSignalCalled;
6832 };
6833
6834 int UtcDaliActorLayoutDirectionSignal(void)
6835 {
6836   TestApplication application;
6837   tet_infoline( "Check changing layout direction property sends a signal" );
6838
6839   Actor actor = Actor::New();
6840   DALI_TEST_EQUALS( actor.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6841   Stage::GetCurrent().Add( actor );
6842   bool signalCalled = false;
6843   LayoutDirectionFunctor layoutDirectionFunctor(signalCalled);
6844
6845   actor.ConnectSignal( &application, "layoutDirectionChanged", layoutDirectionFunctor );
6846   DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
6847
6848   // Test that writing the same value doesn't send a signal
6849   actor.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT );
6850   DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
6851
6852   // Test that writing a different value sends the signal
6853   signalCalled = false;
6854   actor.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT );
6855   DALI_TEST_EQUALS( signalCalled, true, TEST_LOCATION );
6856
6857   signalCalled = false;
6858   actor.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT );
6859   DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
6860
6861   END_TEST;
6862 }
6863
6864 struct ChildAddedSignalCheck
6865 {
6866   ChildAddedSignalCheck( bool& signalReceived, Actor& childHandle )
6867   : mSignalReceived( signalReceived ),
6868     mChildHandle( childHandle )
6869   {
6870   }
6871
6872   void operator() ( Actor childHandle )
6873   {
6874     mSignalReceived = true;
6875     mChildHandle = childHandle;
6876   }
6877   void operator() ()
6878   {
6879     mSignalReceived = true;
6880     mChildHandle = Actor();
6881   }
6882
6883   bool& mSignalReceived;
6884   Actor& mChildHandle;
6885 };
6886
6887 int UtcDaliChildAddedSignalP1(void)
6888 {
6889   TestApplication application;
6890   auto stage = Stage::GetCurrent();
6891
6892   bool signalReceived=false;
6893   Actor childActor;
6894
6895   ChildAddedSignalCheck signal( signalReceived, childActor );
6896   DevelActor::ChildAddedSignal( stage.GetRootLayer() ).Connect( &application, signal );
6897   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
6898
6899   auto actorA = Actor::New();
6900   stage.Add( actorA );
6901   DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
6902   DALI_TEST_EQUALS( childActor, actorA, TEST_LOCATION );
6903   signalReceived = false;
6904
6905   auto actorB = Actor::New();
6906   stage.Add( actorB );
6907   DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
6908   DALI_TEST_EQUALS( childActor, actorB, TEST_LOCATION );
6909
6910   END_TEST;
6911 }
6912
6913
6914 int UtcDaliChildAddedSignalP2(void)
6915 {
6916   TestApplication application;
6917   auto stage = Stage::GetCurrent();
6918
6919   bool signalReceived=false;
6920   Actor childActor;
6921
6922   ChildAddedSignalCheck signal( signalReceived, childActor );
6923   tet_infoline( "Connect to childAdded signal by name" );
6924
6925   stage.GetRootLayer().ConnectSignal( &application, "childAdded", signal );
6926   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
6927
6928   auto actorA = Actor::New();
6929   stage.Add( actorA );
6930   DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
6931
6932   // Can't test which actor was added; signal signature is void() when connecting via name.
6933   signalReceived = false;
6934
6935   auto actorB = Actor::New();
6936   stage.Add( actorB );
6937   DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
6938
6939   END_TEST;
6940 }
6941
6942 int UtcDaliChildAddedSignalN(void)
6943 {
6944   TestApplication application;
6945   auto stage = Stage::GetCurrent();
6946
6947   bool signalReceived=false;
6948   Actor childActor;
6949
6950   ChildAddedSignalCheck signal( signalReceived, childActor );
6951   DevelActor::ChildAddedSignal( stage.GetRootLayer() ).Connect( &application, signal );
6952   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
6953
6954   auto actorA = Actor::New();
6955   stage.Add( actorA );
6956   DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
6957   DALI_TEST_EQUALS( childActor, actorA, TEST_LOCATION );
6958   signalReceived = false;
6959
6960   auto actorB = Actor::New();
6961   actorA.Add( actorB );
6962   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
6963   END_TEST;
6964 }
6965
6966
6967 struct ChildRemovedSignalCheck
6968 {
6969   ChildRemovedSignalCheck( bool& signalReceived, Actor& childHandle )
6970   : mSignalReceived( signalReceived ),
6971     mChildHandle( childHandle )
6972   {
6973   }
6974
6975   void operator() ( Actor childHandle )
6976   {
6977     mSignalReceived = true;
6978     mChildHandle = childHandle;
6979   }
6980
6981   void operator() ()
6982   {
6983     mSignalReceived = true;
6984   }
6985
6986   bool& mSignalReceived;
6987   Actor& mChildHandle;
6988 };
6989
6990 int UtcDaliChildRemovedSignalP1(void)
6991 {
6992   TestApplication application;
6993   auto stage = Stage::GetCurrent();
6994
6995   bool signalReceived=false;
6996   Actor childActor;
6997
6998   ChildRemovedSignalCheck signal( signalReceived, childActor );
6999   DevelActor::ChildRemovedSignal( stage.GetRootLayer() ).Connect( &application, signal );
7000   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
7001
7002   auto actorA = Actor::New();
7003   stage.Add( actorA );
7004   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
7005   DALI_TEST_CHECK( !childActor );
7006
7007   stage.Remove( actorA );
7008   DALI_TEST_EQUALS( childActor, actorA, TEST_LOCATION );
7009   DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
7010
7011   signalReceived = false;
7012   auto actorB = Actor::New();
7013   stage.Add( actorB );
7014   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
7015
7016   stage.Remove( actorB );
7017   DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
7018   DALI_TEST_EQUALS( childActor, actorB, TEST_LOCATION );
7019
7020   END_TEST;
7021 }
7022
7023 int UtcDaliChildRemovedSignalP2(void)
7024 {
7025   TestApplication application;
7026   auto stage = Stage::GetCurrent();
7027
7028   bool signalReceived=false;
7029   Actor childActor;
7030
7031   ChildAddedSignalCheck signal( signalReceived, childActor );
7032   tet_infoline( "Connect to childRemoved signal by name" );
7033
7034   stage.GetRootLayer().ConnectSignal( &application, "childRemoved", signal );
7035   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
7036
7037   auto actorA = Actor::New();
7038   stage.Add( actorA );
7039   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
7040
7041   stage.Remove( actorA );
7042   DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
7043
7044   signalReceived = false;
7045   auto actorB = Actor::New();
7046   stage.Add( actorB );
7047   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
7048
7049   stage.Remove( actorB );
7050   DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
7051
7052   END_TEST;
7053 }
7054
7055
7056 int UtcDaliChildRemovedSignalN(void)
7057 {
7058   TestApplication application;
7059   auto stage = Stage::GetCurrent();
7060
7061   bool signalReceived=false;
7062   Actor childActor;
7063
7064   ChildRemovedSignalCheck signal( signalReceived, childActor );
7065   DevelActor::ChildRemovedSignal( stage.GetRootLayer() ).Connect( &application, signal );
7066   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
7067
7068   auto actorA = Actor::New();
7069   stage.Add( actorA );
7070
7071   auto actorB = Actor::New();
7072   actorA.Add( actorB );
7073
7074   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
7075   DALI_TEST_CHECK( ! childActor );
7076
7077   actorA.Remove( actorB );
7078   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
7079   END_TEST;
7080 }
7081
7082
7083 int UtcDaliChildMovedSignalP(void)
7084 {
7085   TestApplication application;
7086   auto stage = Stage::GetCurrent();
7087
7088   bool addedASignalReceived   = false;
7089   bool removedASignalReceived = false;
7090   bool addedBSignalReceived   = false;
7091   bool removedBSignalReceived = false;
7092   Actor childActor;
7093
7094   auto actorA = Actor::New();
7095   auto actorB = Actor::New();
7096   stage.Add( actorA );
7097   stage.Add( actorB );
7098
7099   ChildAddedSignalCheck addedSignalA( addedASignalReceived, childActor );
7100   ChildRemovedSignalCheck removedSignalA( removedASignalReceived, childActor );
7101   ChildAddedSignalCheck addedSignalB( addedBSignalReceived, childActor );
7102   ChildRemovedSignalCheck removedSignalB( removedBSignalReceived, childActor );
7103
7104   DevelActor::ChildAddedSignal( actorA ).Connect( &application, addedSignalA );
7105   DevelActor::ChildRemovedSignal( actorA ).Connect( &application, removedSignalA );
7106   DevelActor::ChildAddedSignal( actorB ).Connect( &application, addedSignalB );
7107   DevelActor::ChildRemovedSignal( actorB ).Connect( &application, removedSignalB );
7108
7109   DALI_TEST_EQUALS( addedASignalReceived, false, TEST_LOCATION );
7110   DALI_TEST_EQUALS( removedASignalReceived, false, TEST_LOCATION );
7111   DALI_TEST_EQUALS( addedBSignalReceived, false, TEST_LOCATION );
7112   DALI_TEST_EQUALS( removedBSignalReceived, false, TEST_LOCATION );
7113
7114   // Create a child of A
7115
7116   auto child = Actor::New();
7117   actorA.Add( child );
7118
7119   DALI_TEST_EQUALS( addedASignalReceived, true, TEST_LOCATION );
7120   DALI_TEST_EQUALS( removedASignalReceived, false, TEST_LOCATION );
7121   DALI_TEST_EQUALS( addedBSignalReceived, false, TEST_LOCATION );
7122   DALI_TEST_EQUALS( removedBSignalReceived, false, TEST_LOCATION );
7123   DALI_TEST_EQUALS( childActor, child, TEST_LOCATION );
7124
7125   // Move child to B:
7126   addedASignalReceived   = false;
7127   addedBSignalReceived   = false;
7128   removedASignalReceived = false;
7129   removedBSignalReceived = false;
7130
7131   actorB.Add( child ); // Expect this child to be re-parented
7132   DALI_TEST_EQUALS( addedASignalReceived, false, TEST_LOCATION );
7133   DALI_TEST_EQUALS( removedASignalReceived, true, TEST_LOCATION );
7134   DALI_TEST_EQUALS( addedBSignalReceived, true, TEST_LOCATION );
7135   DALI_TEST_EQUALS( removedBSignalReceived, false, TEST_LOCATION );
7136
7137   // Move child back to A:
7138   addedASignalReceived   = false;
7139   addedBSignalReceived   = false;
7140   removedASignalReceived = false;
7141   removedBSignalReceived = false;
7142
7143   actorA.Add( child ); // Expect this child to be re-parented
7144   DALI_TEST_EQUALS( addedASignalReceived, true, TEST_LOCATION );
7145   DALI_TEST_EQUALS( removedASignalReceived, false, TEST_LOCATION );
7146   DALI_TEST_EQUALS( addedBSignalReceived, false, TEST_LOCATION );
7147   DALI_TEST_EQUALS( removedBSignalReceived, true, TEST_LOCATION );
7148
7149
7150   END_TEST;
7151 }
7152
7153 int utcDaliActorCulled(void)
7154 {
7155   TestApplication application;
7156   auto stage = Stage::GetCurrent();
7157
7158   tet_infoline( "Check that the actor is culled if the actor is out of the screen" );
7159
7160   Actor actor = Actor::New();
7161   actor.SetSize( 10.0f, 10.0f );
7162
7163   Geometry geometry = CreateQuadGeometry();
7164   Shader shader = CreateShader();
7165   Renderer renderer = Renderer::New(geometry, shader);
7166   actor.AddRenderer( renderer );
7167
7168   stage.Add( actor );
7169
7170   application.SendNotification();
7171   application.Render( 0 );
7172
7173   DALI_TEST_EQUALS( actor.GetProperty< bool >( DevelActor::Property::CULLED ), false, TEST_LOCATION );
7174
7175   PropertyNotification notification = actor.AddPropertyNotification( DevelActor::Property::CULLED, LessThanCondition( 0.5f ) );
7176   notification.SetNotifyMode( PropertyNotification::NotifyOnChanged );
7177
7178   // Connect NotifySignal
7179   bool propertyNotificationSignal( false );
7180   PropertyNotification source;
7181   CulledPropertyNotificationFunctor f( propertyNotificationSignal, source );
7182   notification.NotifySignal().Connect( &application, f ) ;
7183
7184   actor.SetPosition( 1000.0f, 1000.0f );
7185
7186   application.SendNotification();
7187   application.Render();
7188
7189   application.SendNotification();
7190
7191   DALI_TEST_EQUALS( actor.GetProperty< bool >( DevelActor::Property::CULLED ), true, TEST_LOCATION );
7192
7193   DALI_TEST_EQUALS( propertyNotificationSignal, true, TEST_LOCATION );
7194   DALI_TEST_EQUALS( source.GetTargetProperty(), static_cast< int >( DevelActor::Property::CULLED ), TEST_LOCATION );
7195   DALI_TEST_EQUALS( source.GetTarget().GetProperty< bool >( source.GetTargetProperty() ), true, TEST_LOCATION );
7196
7197   END_TEST;
7198 }
7199
7200 int UtcDaliActorUpdateSizeHint(void)
7201 {
7202   TestApplication application;
7203
7204   Actor actor = Actor::New();
7205   Vector3 vector(100.0f, 100.0f, 0.0f);
7206
7207   DALI_TEST_CHECK(vector != actor.GetCurrentSize());
7208
7209   actor.SetSize(vector.x, vector.y);
7210
7211
7212   Vector2 updateSizeHint = Vector2(150.f, 150.f);
7213   actor.SetProperty(Dali::DevelActor::Property::UPDATE_SIZE_HINT, updateSizeHint);
7214
7215   // Flush the queue and render once
7216   application.SendNotification();
7217   application.Render();
7218
7219
7220   Vector2 currentSizeHint = actor.GetProperty( Dali::DevelActor::Property::UPDATE_SIZE_HINT ).Get< Vector2 >();
7221   DALI_TEST_EQUALS( currentSizeHint, updateSizeHint, Math::MACHINE_EPSILON_0, TEST_LOCATION );
7222
7223   // Flush the queue and render once
7224   application.SendNotification();
7225   application.Render();
7226
7227   END_TEST;
7228 }
7229
7230 int utcDaliEnsureRenderWhenRemovingLastRenderableActor(void)
7231 {
7232   TestApplication application;
7233   auto stage = Stage::GetCurrent();
7234
7235   tet_infoline( "Ensure we clear the screen when the last actor is removed" );
7236
7237   Actor actor = CreateRenderableActor();
7238   actor.SetSize( 100.0f, 100.0f );
7239   stage.Add( actor );
7240
7241   application.SendNotification();
7242   application.Render();
7243
7244   auto& glAbstraction = application.GetGlAbstraction();
7245   const auto clearCountBefore = glAbstraction.GetClearCountCalled();
7246
7247   actor.Unparent();
7248
7249   application.SendNotification();
7250   application.Render();
7251
7252   DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION );
7253
7254   END_TEST;
7255 }
7256
7257 int utcDaliEnsureRenderWhenMakingLastActorInvisible(void)
7258 {
7259   TestApplication application;
7260   auto stage = Stage::GetCurrent();
7261
7262   tet_infoline( "Ensure we clear the screen when the last actor is made invisible" );
7263
7264   Actor actor = CreateRenderableActor();
7265   actor.SetSize( 100.0f, 100.0f );
7266   stage.Add( actor );
7267
7268   application.SendNotification();
7269   application.Render();
7270
7271   auto& glAbstraction = application.GetGlAbstraction();
7272   const auto clearCountBefore = glAbstraction.GetClearCountCalled();
7273
7274   actor.SetVisible( false );
7275
7276   application.SendNotification();
7277   application.Render();
7278
7279   DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION );
7280
7281   END_TEST;
7282 }