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

   1 /*
   2  * Copyright (c) 2021 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 // Enable debug log for test coverage
  19 #define DEBUG_ENABLED 1
  20
  21 #include <dali-test-suite-utils.h>
  22 #include <dali/devel-api/actors/actor-devel.h>
  23 #include <dali/devel-api/common/capabilities.h>
  24 #include <dali/integration-api/debug.h>
  25 #include <dali/integration-api/events/hover-event-integ.h>
  26 #include <dali/integration-api/events/touch-event-integ.h>
  27 #include <dali/public-api/dali-core.h>
  28 #include <mesh-builder.h>
  29 #include <test-actor-utils.h>
  30
  31 #include <cfloat> // For FLT_MAX
  32 #include <string>
  33
  34 #include "assert.h"
  35
  36 //& set: DaliActor
  37
  38 using std::string;
  39 using namespace Dali;
  40
  41 void utc_dali_actor_startup(void)
  42 {
  43   test_return_value = TET_UNDEF;
  44 }
  45
  46 void utc_dali_actor_cleanup(void)
  47 {
  48   test_return_value = TET_PASS;
  49 }
  50
  51 namespace
  52 {
  53 bool gTouchCallBackCalled  = false;
  54 bool gTouchCallBackCalled2 = false;
  55 bool gTouchCallBackCalled3 = false;
  56
  57 bool gHoverCallBackCalled = false;
  58
  59 static bool gTestConstraintCalled;
  60
  61 LayoutDirection::Type gLayoutDirectionType;
  62
  63 struct TestConstraint
  64 {
  65   void operator()(Vector4& color, const PropertyInputContainer& /* inputs */)
  66   {
  67     gTestConstraintCalled = true;
  68   }
  69 };
  70
  71 /**
  72  * TestConstraint reference.
  73  * When constraint is called, the resultRef is updated
  74  * with the value supplied.
  75  */
  76 template<typename T>
  77 struct TestConstraintRef
  78 {
  79   TestConstraintRef(unsigned int& resultRef, unsigned int value)
  80   : mResultRef(resultRef),
  81     mValue(value)
  82   {
  83   }
  84
  85   void operator()(T& current, const PropertyInputContainer& /* inputs */)
  86   {
  87     mResultRef = mValue;
  88   }
  89
  90   unsigned int& mResultRef;
  91   unsigned int  mValue;
  92 };
  93
  94 static bool TestTouchCallback(Actor, const TouchEvent&)
  95 {
  96   gTouchCallBackCalled = true;
  97   return true;
  98   END_TEST;
  99 }
 100
 101 static bool TestTouchCallback2(Actor, const TouchEvent&)
 102 {
 103   gTouchCallBackCalled2 = true;
 104   return true;
 105   END_TEST;
 106 }
 107
 108 static bool TestTouchCallback3(Actor, const TouchEvent&)
 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> gActorNamesOnOffScene;
 131 static int                      gOnSceneCallBackCalled;
 132 void                            OnSceneCallback(Actor actor)
 133 {
 134   ++gOnSceneCallBackCalled;
 135   gActorNamesOnOffScene.push_back(actor.GetProperty<std::string>(Actor::Property::NAME));
 136   DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE) == true);
 137 }
 138 static int gOffSceneCallBackCalled;
 139 void       OffSceneCallback(Actor actor)
 140 {
 141   ++gOffSceneCallBackCalled;
 142   gActorNamesOnOffScene.push_back(actor.GetProperty<std::string>(Actor::Property::NAME));
 143   DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE) == false);
 144 }
 145
 146 struct PositionComponentConstraint
 147 {
 148   PositionComponentConstraint()
 149   {
 150   }
 151
 152   void operator()(Vector3& pos, const PropertyInputContainer& inputs)
 153   {
 154     const Matrix& m = inputs[0]->GetMatrix();
 155     Vector3       scale;
 156     Quaternion    rot;
 157     m.GetTransformComponents(pos, rot, scale);
 158   }
 159 };
 160
 161 struct OrientationComponentConstraint
 162 {
 163   OrientationComponentConstraint()
 164   {
 165   }
 166
 167   void operator()(Quaternion& orientation, const PropertyInputContainer& inputs)
 168   {
 169     const Quaternion& parentOrientation = inputs[0]->GetQuaternion();
 170     Vector3           pos, scale;
 171     Quaternion        rot;
 172     orientation = parentOrientation;
 173   }
 174 };
 175 // OnRelayout
 176
 177 static bool                     gOnRelayoutCallBackCalled = false;
 178 static std::vector<std::string> gActorNamesRelayout;
 179
 180 void OnRelayoutCallback(Actor actor)
 181 {
 182   gOnRelayoutCallBackCalled = true;
 183   gActorNamesRelayout.push_back(actor.GetProperty<std::string>(Actor::Property::NAME));
 184 }
 185
 186 struct VisibilityChangedFunctorData
 187 {
 188   VisibilityChangedFunctorData()
 189   : actor(),
 190     visible(false),
 191     type(DevelActor::VisibilityChange::SELF),
 192     called(false)
 193   {
 194   }
 195
 196   void Reset()
 197   {
 198     actor.Reset();
 199     visible = false;
 200     type    = DevelActor::VisibilityChange::SELF;
 201     called  = false;
 202   }
 203
 204   void Check(bool compareCalled, Actor compareActor, bool compareVisible, DevelActor::VisibilityChange::Type compareType, const char* location)
 205   {
 206     DALI_TEST_EQUALS(called, compareCalled, TEST_INNER_LOCATION(location));
 207     DALI_TEST_EQUALS(actor, compareActor, TEST_INNER_LOCATION(location));
 208     DALI_TEST_EQUALS(visible, compareVisible, TEST_INNER_LOCATION(location));
 209     DALI_TEST_EQUALS((int)type, (int)compareType, TEST_INNER_LOCATION(location));
 210   }
 211
 212   void Check(bool compareCalled, const std::string& location)
 213   {
 214     DALI_TEST_EQUALS(called, compareCalled, TEST_INNER_LOCATION(location));
 215   }
 216
 217   Actor                              actor;
 218   bool                               visible;
 219   DevelActor::VisibilityChange::Type type;
 220   bool                               called;
 221 };
 222
 223 struct VisibilityChangedFunctor
 224 {
 225   VisibilityChangedFunctor(VisibilityChangedFunctorData& dataVar)
 226   : data(dataVar)
 227   {
 228   }
 229
 230   void operator()(Actor actor, bool visible, DevelActor::VisibilityChange::Type type)
 231   {
 232     data.actor   = actor;
 233     data.visible = visible;
 234     data.type    = type;
 235     data.called  = true;
 236   }
 237
 238   VisibilityChangedFunctorData& data;
 239 };
 240
 241 struct VisibilityChangedVoidFunctor
 242 {
 243   VisibilityChangedVoidFunctor(bool& signalCalled)
 244   : mSignalCalled(signalCalled)
 245   {
 246   }
 247
 248   void operator()()
 249   {
 250     mSignalCalled = true;
 251   }
 252
 253   bool& mSignalCalled;
 254 };
 255
 256 struct ChildOrderChangedFunctor
 257 {
 258   ChildOrderChangedFunctor(bool& signalCalled, Actor& actor)
 259   : mSignalCalled(signalCalled),
 260     mActor(actor)
 261   {
 262   }
 263
 264   void operator()(Actor actor)
 265   {
 266     mSignalCalled = true;
 267     mActor        = actor;
 268   }
 269
 270   bool&  mSignalCalled;
 271   Actor& mActor;
 272 };
 273
 274 struct CulledPropertyNotificationFunctor
 275 {
 276   CulledPropertyNotificationFunctor(bool& signalCalled, PropertyNotification& propertyNotification)
 277   : mSignalCalled(signalCalled),
 278     mPropertyNotification(propertyNotification)
 279   {
 280   }
 281
 282   void operator()(PropertyNotification& source)
 283   {
 284     mSignalCalled         = true;
 285     mPropertyNotification = source;
 286   }
 287
 288   bool&                 mSignalCalled;
 289   PropertyNotification& mPropertyNotification;
 290 };
 291
 292 } // anonymous namespace
 293
 294 //& purpose: Testing New API
 295 int UtcDaliActorNew(void)
 296 {
 297   TestApplication application;
 298
 299   Actor actor = Actor::New();
 300
 301   DALI_TEST_CHECK(actor);
 302   END_TEST;
 303 }
 304
 305 //& purpose: Testing Dali::Actor::DownCast()
 306 int UtcDaliActorDownCastP(void)
 307 {
 308   TestApplication application;
 309   tet_infoline("Testing Dali::Actor::DownCast()");
 310
 311   Actor      actor = Actor::New();
 312   BaseHandle object(actor);
 313   Actor      actor2 = Actor::DownCast(object);
 314   DALI_TEST_CHECK(actor2);
 315   END_TEST;
 316 }
 317
 318 //& purpose: Testing Dali::Actor::DownCast()
 319 int UtcDaliActorDownCastN(void)
 320 {
 321   TestApplication application;
 322   tet_infoline("Testing Dali::Actor::DownCast()");
 323
 324   BaseHandle unInitializedObject;
 325   Actor      actor = Actor::DownCast(unInitializedObject);
 326   DALI_TEST_CHECK(!actor);
 327   END_TEST;
 328 }
 329
 330 int UtcDaliActorMoveConstructor(void)
 331 {
 332   TestApplication application;
 333
 334   Actor actor = Actor::New();
 335   DALI_TEST_CHECK(actor);
 336
 337   int id = actor.GetProperty<int>(Actor::Property::ID);
 338
 339   Actor moved = std::move(actor);
 340   DALI_TEST_CHECK(moved);
 341   DALI_TEST_EQUALS(id, moved.GetProperty<int>(Actor::Property::ID), TEST_LOCATION);
 342   DALI_TEST_CHECK(!actor);
 343
 344   END_TEST;
 345 }
 346
 347 int UtcDaliActorMoveAssignment(void)
 348 {
 349   TestApplication application;
 350
 351   Actor actor = Actor::New();
 352   DALI_TEST_CHECK(actor);
 353
 354   int id = actor.GetProperty<int>(Actor::Property::ID);
 355
 356   Actor moved;
 357   moved = std::move(actor);
 358   DALI_TEST_CHECK(moved);
 359   DALI_TEST_EQUALS(id, moved.GetProperty<int>(Actor::Property::ID), TEST_LOCATION);
 360   DALI_TEST_CHECK(!actor);
 361
 362   END_TEST;
 363 }
 364
 365 //& purpose: Testing Dali::Actor::GetName()
 366 int UtcDaliActorGetName(void)
 367 {
 368   TestApplication application;
 369
 370   Actor actor = Actor::New();
 371
 372   DALI_TEST_CHECK(actor.GetProperty<std::string>(Actor::Property::NAME).empty());
 373   END_TEST;
 374 }
 375
 376 //& purpose: Testing Dali::Actor::SetName()
 377 int UtcDaliActorSetName(void)
 378 {
 379   TestApplication application;
 380
 381   string str("ActorName");
 382   Actor  actor = Actor::New();
 383
 384   actor.SetProperty(Actor::Property::NAME, str);
 385   DALI_TEST_CHECK(actor.GetProperty<std::string>(Actor::Property::NAME) == str);
 386   END_TEST;
 387 }
 388
 389 int UtcDaliActorGetId(void)
 390 {
 391   tet_infoline("Testing Dali::Actor::UtcDaliActo.GetProperty< int >( Actor::Property::ID )");
 392   TestApplication application;
 393
 394   Actor first  = Actor::New();
 395   Actor second = Actor::New();
 396   Actor third  = Actor::New();
 397
 398   DALI_TEST_CHECK(first.GetProperty<int>(Actor::Property::ID) != second.GetProperty<int>(Actor::Property::ID));
 399   DALI_TEST_CHECK(second.GetProperty<int>(Actor::Property::ID) != third.GetProperty<int>(Actor::Property::ID));
 400   END_TEST;
 401 }
 402
 403 int UtcDaliActorIsRoot(void)
 404 {
 405   TestApplication application;
 406
 407   Actor actor = Actor::New();
 408   DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::IS_ROOT));
 409
 410   // get the root layer
 411   actor = application.GetScene().GetLayer(0);
 412   DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::IS_ROOT));
 413   END_TEST;
 414 }
 415
 416 int UtcDaliActorOnScene(void)
 417 {
 418   TestApplication application;
 419
 420   Actor actor = Actor::New();
 421   DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
 422
 423   // get the root layer
 424   actor = application.GetScene().GetLayer(0);
 425   DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
 426   END_TEST;
 427 }
 428
 429 int UtcDaliActorIsLayer(void)
 430 {
 431   TestApplication application;
 432
 433   Actor actor = Actor::New();
 434   DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::IS_LAYER));
 435
 436   // get the root layer
 437   actor = application.GetScene().GetLayer(0);
 438   DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::IS_LAYER));
 439   END_TEST;
 440 }
 441
 442 int UtcDaliActorGetLayer(void)
 443 {
 444   TestApplication application;
 445
 446   Actor actor = Actor::New();
 447   application.GetScene().Add(actor);
 448   Layer layer = actor.GetLayer();
 449
 450   DALI_TEST_CHECK(layer);
 451
 452   // get the root layers layer
 453   actor = application.GetScene().GetLayer(0);
 454   DALI_TEST_CHECK(actor.GetLayer());
 455   END_TEST;
 456 }
 457
 458 int UtcDaliActorAddP(void)
 459 {
 460   tet_infoline("Testing Actor::Add");
 461   TestApplication application;
 462
 463   Actor parent = Actor::New();
 464   Actor child  = Actor::New();
 465
 466   DALI_TEST_EQUALS(parent.GetChildCount(), 0u, TEST_LOCATION);
 467
 468   parent.Add(child);
 469
 470   DALI_TEST_EQUALS(parent.GetChildCount(), 1u, TEST_LOCATION);
 471
 472   Actor parent2 = Actor::New();
 473   parent2.Add(child);
 474
 475   DALI_TEST_EQUALS(parent.GetChildCount(), 0u, TEST_LOCATION);
 476   DALI_TEST_EQUALS(parent2.GetChildCount(), 1u, TEST_LOCATION);
 477
 478   // try Adding to same parent again, works
 479   parent2.Add(child);
 480   DALI_TEST_EQUALS(parent2.GetChildCount(), 1u, TEST_LOCATION);
 481
 482   // try reparenting an orphaned child
 483   {
 484     Actor temporaryParent = Actor::New();
 485     temporaryParent.Add(child);
 486     DALI_TEST_EQUALS(parent2.GetChildCount(), 0u, TEST_LOCATION);
 487   }
 488   // temporaryParent has now died, reparent the orphaned child
 489   parent2.Add(child);
 490   DALI_TEST_EQUALS(parent2.GetChildCount(), 1u, TEST_LOCATION);
 491
 492   END_TEST;
 493 }
 494
 495 int UtcDaliActorAddN(void)
 496 {
 497   tet_infoline("Testing Actor::Add");
 498   TestApplication application;
 499
 500   Actor child = Actor::New();
 501
 502   Actor parent2 = Actor::New();
 503   parent2.Add(child);
 504
 505   // try illegal Add
 506   try
 507   {
 508     parent2.Add(parent2);
 509     tet_printf("Assertion test failed - no Exception\n");
 510     tet_result(TET_FAIL);
 511   }
 512   catch(Dali::DaliException& e)
 513   {
 514     DALI_TEST_PRINT_ASSERT(e);
 515     DALI_TEST_ASSERT(e, "&mOwner != &child", TEST_LOCATION);
 516     DALI_TEST_EQUALS(parent2.GetChildCount(), 1u, TEST_LOCATION);
 517   }
 518   catch(...)
 519   {
 520     tet_printf("Assertion test failed - wrong Exception\n");
 521     tet_result(TET_FAIL);
 522   }
 523
 524   // try reparenting root
 525   try
 526   {
 527     parent2.Add(application.GetScene().GetLayer(0));
 528     tet_printf("Assertion test failed - no Exception\n");
 529     tet_result(TET_FAIL);
 530   }
 531   catch(Dali::DaliException& e)
 532   {
 533     DALI_TEST_PRINT_ASSERT(e);
 534     DALI_TEST_ASSERT(e, "!child.IsRoot()", TEST_LOCATION);
 535     DALI_TEST_EQUALS(parent2.GetChildCount(), 1u, TEST_LOCATION);
 536   }
 537   catch(...)
 538   {
 539     tet_printf("Assertion test failed - wrong Exception\n");
 540     tet_result(TET_FAIL);
 541   }
 542
 543   // try Add empty
 544   try
 545   {
 546     Actor empty;
 547     parent2.Add(empty);
 548     tet_printf("Assertion test failed - no Exception\n");
 549     tet_result(TET_FAIL);
 550   }
 551   catch(Dali::DaliException& e)
 552   {
 553     DALI_TEST_PRINT_ASSERT(e);
 554     DALI_TEST_ASSERT(e, "actor", TEST_LOCATION);
 555     DALI_TEST_EQUALS(parent2.GetChildCount(), 1u, TEST_LOCATION);
 556   }
 557   catch(...)
 558   {
 559     tet_printf("Assertion test failed - wrong Exception\n");
 560     tet_result(TET_FAIL);
 561   }
 562
 563   END_TEST;
 564 }
 565
 566 int UtcDaliActorRemoveN(void)
 567 {
 568   tet_infoline("Testing Actor::Remove");
 569   TestApplication application;
 570
 571   Actor parent = Actor::New();
 572   Actor child  = Actor::New();
 573   DALI_TEST_EQUALS(parent.GetChildCount(), 0u, TEST_LOCATION);
 574
 575   parent.Add(child);
 576   DALI_TEST_EQUALS(parent.GetChildCount(), 1u, TEST_LOCATION);
 577
 578   parent.Remove(child);
 579   DALI_TEST_EQUALS(parent.GetChildCount(), 0u, TEST_LOCATION);
 580
 581   // remove again, no problem
 582   parent.Remove(child);
 583   DALI_TEST_EQUALS(parent.GetChildCount(), 0u, TEST_LOCATION);
 584
 585   // add child back
 586   parent.Add(child);
 587   DALI_TEST_EQUALS(parent.GetChildCount(), 1u, TEST_LOCATION);
 588   // try Remove self, its a no-op
 589   parent.Remove(parent);
 590   DALI_TEST_EQUALS(parent.GetChildCount(), 1u, TEST_LOCATION);
 591
 592   // try Remove empty
 593   try
 594   {
 595     Actor empty;
 596     parent.Remove(empty);
 597     tet_printf("Assertion test failed - no Exception\n");
 598     tet_result(TET_FAIL);
 599   }
 600   catch(Dali::DaliException& e)
 601   {
 602     DALI_TEST_PRINT_ASSERT(e);
 603     DALI_TEST_ASSERT(e, "actor", TEST_LOCATION);
 604     DALI_TEST_EQUALS(parent.GetChildCount(), 1u, TEST_LOCATION);
 605   }
 606   catch(...)
 607   {
 608     tet_printf("Assertion test failed - wrong Exception\n");
 609     tet_result(TET_FAIL);
 610   }
 611   END_TEST;
 612 }
 613
 614 int UtcDaliActorRemoveP(void)
 615 {
 616   TestApplication application;
 617
 618   Actor parent = Actor::New();
 619   Actor child  = Actor::New();
 620   Actor random = Actor::New();
 621
 622   application.GetScene().Add(parent);
 623
 624   DALI_TEST_CHECK(parent.GetChildCount() == 0);
 625
 626   parent.Add(child);
 627
 628   DALI_TEST_CHECK(parent.GetChildCount() == 1);
 629
 630   parent.Remove(random);
 631
 632   DALI_TEST_CHECK(parent.GetChildCount() == 1);
 633
 634   application.GetScene().Remove(parent);
 635
 636   DALI_TEST_CHECK(parent.GetChildCount() == 1);
 637   END_TEST;
 638 }
 639
 640 int UtcDaliActorGetChildCount(void)
 641 {
 642   TestApplication application;
 643
 644   Actor parent = Actor::New();
 645   Actor child  = Actor::New();
 646
 647   DALI_TEST_CHECK(parent.GetChildCount() == 0);
 648
 649   parent.Add(child);
 650
 651   DALI_TEST_CHECK(parent.GetChildCount() == 1);
 652   END_TEST;
 653 }
 654
 655 int UtcDaliActorGetChildren01(void)
 656 {
 657   TestApplication application;
 658
 659   Actor parent = Actor::New();
 660   Actor first  = Actor::New();
 661   Actor second = Actor::New();
 662   Actor third  = Actor::New();
 663
 664   parent.Add(first);
 665   parent.Add(second);
 666   parent.Add(third);
 667
 668   DALI_TEST_CHECK(parent.GetChildAt(0) == first);
 669   DALI_TEST_CHECK(parent.GetChildAt(1) == second);
 670   DALI_TEST_CHECK(parent.GetChildAt(2) == third);
 671   END_TEST;
 672 }
 673
 674 int UtcDaliActorGetChildren02(void)
 675 {
 676   TestApplication application;
 677
 678   Actor parent = Actor::New();
 679   Actor first  = Actor::New();
 680   Actor second = Actor::New();
 681   Actor third  = Actor::New();
 682
 683   parent.Add(first);
 684   parent.Add(second);
 685   parent.Add(third);
 686
 687   const Actor& constParent = parent;
 688
 689   DALI_TEST_CHECK(constParent.GetChildAt(0) == first);
 690   DALI_TEST_CHECK(constParent.GetChildAt(1) == second);
 691   DALI_TEST_CHECK(constParent.GetChildAt(2) == third);
 692   END_TEST;
 693 }
 694
 695 int UtcDaliActorGetParent01(void)
 696 {
 697   TestApplication application;
 698
 699   Actor parent = Actor::New();
 700   Actor child  = Actor::New();
 701
 702   parent.Add(child);
 703
 704   DALI_TEST_CHECK(child.GetParent() == parent);
 705   END_TEST;
 706 }
 707
 708 int UtcDaliActorGetParent02(void)
 709 {
 710   TestApplication application;
 711
 712   Actor actor = Actor::New();
 713
 714   DALI_TEST_CHECK(!actor.GetParent());
 715   END_TEST;
 716 }
 717
 718 int UtcDaliActorCustomProperty(void)
 719 {
 720   TestApplication application;
 721
 722   Actor actor = Actor::New();
 723   application.GetScene().Add(actor);
 724
 725   float           startValue(1.0f);
 726   Property::Index index = actor.RegisterProperty("testProperty", startValue);
 727   DALI_TEST_CHECK(actor.GetProperty<float>(index) == startValue);
 728
 729   application.SendNotification();
 730   application.Render(0);
 731   DALI_TEST_CHECK(actor.GetProperty<float>(index) == startValue);
 732
 733   actor.SetProperty(index, 5.0f);
 734
 735   application.SendNotification();
 736   application.Render(0);
 737   DALI_TEST_CHECK(actor.GetProperty<float>(index) == 5.0f);
 738   END_TEST;
 739 }
 740
 741 int UtcDaliActorCustomPropertyIntToFloat(void)
 742 {
 743   TestApplication application;
 744
 745   Actor actor = Actor::New();
 746   application.GetScene().Add(actor);
 747
 748   float           startValue(5.0f);
 749   Property::Index index = actor.RegisterProperty("testProperty", startValue);
 750   DALI_TEST_CHECK(actor.GetProperty<float>(index) == startValue);
 751
 752   application.SendNotification();
 753   application.Render(0);
 754   DALI_TEST_CHECK(actor.GetProperty<float>(index) == startValue);
 755
 756   actor.SetProperty(index, int(1));
 757
 758   application.SendNotification();
 759   application.Render(0);
 760   DALI_TEST_CHECK(actor.GetProperty<float>(index) == 1.0f);
 761   END_TEST;
 762 }
 763
 764 int UtcDaliActorCustomPropertyFloatToInt(void)
 765 {
 766   TestApplication application;
 767
 768   Actor actor = Actor::New();
 769   application.GetScene().Add(actor);
 770
 771   int             startValue(5);
 772   Property::Index index = actor.RegisterProperty("testProperty", startValue);
 773   DALI_TEST_CHECK(actor.GetProperty<int>(index) == startValue);
 774
 775   application.SendNotification();
 776   application.Render(0);
 777   DALI_TEST_CHECK(actor.GetProperty<int>(index) == startValue);
 778
 779   actor.SetProperty(index, float(1.5));
 780
 781   application.SendNotification();
 782   application.Render(0);
 783   DALI_TEST_CHECK(actor.GetProperty<int>(index) == 1);
 784   END_TEST;
 785 }
 786
 787 int UtcDaliActorSetParentOrigin(void)
 788 {
 789   TestApplication application;
 790
 791   Actor actor = Actor::New();
 792
 793   Vector3 vector(0.7f, 0.8f, 0.9f);
 794   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN));
 795
 796   actor.SetProperty(Actor::Property::PARENT_ORIGIN, vector);
 797
 798   // flush the queue and render once
 799   application.SendNotification();
 800   application.Render();
 801
 802   DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN));
 803
 804   application.GetScene().Add(actor);
 805
 806   actor.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.1f, 0.2f, 0.3f));
 807
 808   // flush the queue and render once
 809   application.SendNotification();
 810   application.Render();
 811
 812   DALI_TEST_EQUALS(Vector3(0.1f, 0.2f, 0.3f), actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), TEST_LOCATION);
 813
 814   application.GetScene().Remove(actor);
 815   END_TEST;
 816 }
 817
 818 int UtcDaliActorSetParentOriginIndividual(void)
 819 {
 820   TestApplication application;
 821
 822   Actor actor = Actor::New();
 823
 824   Vector3 vector(0.7f, 0.8f, 0.9f);
 825   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN));
 826
 827   actor.SetProperty(Actor::Property::PARENT_ORIGIN_X, vector.x);
 828
 829   // flush the queue and render once
 830   application.SendNotification();
 831   application.Render();
 832
 833   DALI_TEST_EQUALS(vector.x, actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN).x, TEST_LOCATION);
 834
 835   actor.SetProperty(Actor::Property::PARENT_ORIGIN_Y, vector.y);
 836
 837   // flush the queue and render once
 838   application.SendNotification();
 839   application.Render();
 840
 841   DALI_TEST_EQUALS(vector.y, actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN).y, TEST_LOCATION);
 842
 843   actor.SetProperty(Actor::Property::PARENT_ORIGIN_Z, vector.z);
 844
 845   // flush the queue and render once
 846   application.SendNotification();
 847   application.Render();
 848
 849   DALI_TEST_EQUALS(vector.z, actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN).z, TEST_LOCATION);
 850
 851   END_TEST;
 852 }
 853
 854 int UtcDaliActorGetCurrentParentOrigin(void)
 855 {
 856   TestApplication application;
 857
 858   Actor actor = Actor::New();
 859
 860   Vector3 vector(0.7f, 0.8f, 0.9f);
 861   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN));
 862
 863   actor.SetProperty(Actor::Property::PARENT_ORIGIN, vector);
 864
 865   // flush the queue and render once
 866   application.SendNotification();
 867   application.Render();
 868
 869   DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN));
 870   END_TEST;
 871 }
 872
 873 int UtcDaliActorSetAnchorPoint(void)
 874 {
 875   TestApplication application;
 876
 877   Actor actor = Actor::New();
 878
 879   Vector3 vector(0.7f, 0.8f, 0.9f);
 880   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT));
 881
 882   actor.SetProperty(Actor::Property::ANCHOR_POINT, vector);
 883
 884   // flush the queue and render once
 885   application.SendNotification();
 886   application.Render();
 887
 888   DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT));
 889
 890   application.GetScene().Add(actor);
 891
 892   actor.SetProperty(Actor::Property::ANCHOR_POINT, Vector3(0.1f, 0.2f, 0.3f));
 893   // flush the queue and render once
 894   application.SendNotification();
 895   application.Render();
 896
 897   DALI_TEST_EQUALS(Vector3(0.1f, 0.2f, 0.3f), actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), TEST_LOCATION);
 898
 899   application.GetScene().Remove(actor);
 900   END_TEST;
 901 }
 902
 903 int UtcDaliActorSetAnchorPointIndividual(void)
 904 {
 905   TestApplication application;
 906
 907   Actor actor = Actor::New();
 908
 909   Vector3 vector(0.7f, 0.8f, 0.9f);
 910   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT));
 911
 912   actor.SetProperty(Actor::Property::ANCHOR_POINT_X, vector.x);
 913
 914   // flush the queue and render once
 915   application.SendNotification();
 916   application.Render();
 917
 918   DALI_TEST_EQUALS(vector.x, actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT).x, TEST_LOCATION);
 919
 920   actor.SetProperty(Actor::Property::ANCHOR_POINT_Y, vector.y);
 921
 922   // flush the queue and render once
 923   application.SendNotification();
 924   application.Render();
 925
 926   DALI_TEST_EQUALS(vector.y, actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT).y, TEST_LOCATION);
 927
 928   actor.SetProperty(Actor::Property::ANCHOR_POINT_Z, vector.z);
 929
 930   // flush the queue and render once
 931   application.SendNotification();
 932   application.Render();
 933
 934   DALI_TEST_EQUALS(vector.z, actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT).z, TEST_LOCATION);
 935
 936   END_TEST;
 937 }
 938
 939 int UtcDaliActorGetCurrentAnchorPoint(void)
 940 {
 941   TestApplication application;
 942
 943   Actor actor = Actor::New();
 944
 945   Vector3 vector(0.7f, 0.8f, 0.9f);
 946   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT));
 947
 948   actor.SetProperty(Actor::Property::ANCHOR_POINT, vector);
 949
 950   // flush the queue and render once
 951   application.SendNotification();
 952   application.Render();
 953
 954   DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT));
 955   END_TEST;
 956 }
 957
 958 int UtcDaliActorSetSize01(void)
 959 {
 960   TestApplication application;
 961
 962   Actor   actor = Actor::New();
 963   Vector3 vector(100.0f, 100.0f, 0.0f);
 964
 965   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
 966
 967   actor.SetProperty(Actor::Property::SIZE, Vector2(vector.x, vector.y));
 968
 969   // Immediately retrieve the size after setting
 970   Vector3 currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
 971   DALI_TEST_EQUALS(currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION);
 972   DALI_TEST_EQUALS(vector.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
 973   DALI_TEST_EQUALS(vector.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
 974   DALI_TEST_EQUALS(vector.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
 975
 976   // Flush the queue and render once
 977   application.SendNotification();
 978   application.Render();
 979
 980   // Check the size in the new frame
 981   DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
 982
 983   currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
 984   DALI_TEST_EQUALS(currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION);
 985   DALI_TEST_EQUALS(vector.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
 986   DALI_TEST_EQUALS(vector.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
 987   DALI_TEST_EQUALS(vector.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
 988
 989   // Check async behaviour
 990   currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
 991   DALI_TEST_EQUALS(currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION);
 992   DALI_TEST_EQUALS(vector.width, actor.GetCurrentProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
 993   DALI_TEST_EQUALS(vector.height, actor.GetCurrentProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
 994   DALI_TEST_EQUALS(vector.depth, actor.GetCurrentProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
 995
 996   // Change the resize policy and check whether the size stays the same
 997   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
 998
 999   currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
1000   DALI_TEST_EQUALS(currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1001
1002   // Set a new size after resize policy is changed and check the new size
1003   actor.SetProperty(Actor::Property::SIZE, Vector3(0.1f, 0.2f, 0.0f));
1004
1005   currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
1006   DALI_TEST_EQUALS(currentSize, Vector3(0.1f, 0.2f, 0.0f), Math::MACHINE_EPSILON_0, TEST_LOCATION);
1007
1008   // Change the resize policy again and check whether the new size stays the same
1009   actor.SetResizePolicy(ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS);
1010
1011   currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
1012   DALI_TEST_EQUALS(currentSize, Vector3(0.1f, 0.2f, 0.0f), Math::MACHINE_EPSILON_0, TEST_LOCATION);
1013
1014   // Set another new size after resize policy is changed and check the new size
1015   actor.SetProperty(Actor::Property::SIZE, Vector3(50.0f, 60.0f, 0.0f));
1016
1017   currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
1018   DALI_TEST_EQUALS(currentSize, Vector3(50.0f, 60.0f, 0.0f), Math::MACHINE_EPSILON_0, TEST_LOCATION);
1019
1020   END_TEST;
1021 }
1022
1023 int UtcDaliActorSetSize02(void)
1024 {
1025   TestApplication application;
1026
1027   Actor   actor = Actor::New();
1028   Vector3 vector(100.0f, 100.0f, 100.0f);
1029
1030   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
1031
1032   actor.SetProperty(Actor::Property::SIZE, Vector3(vector.x, vector.y, vector.z));
1033
1034   // Immediately check the size after setting
1035   Vector3 currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
1036   DALI_TEST_EQUALS(currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1037
1038   // flush the queue and render once
1039   application.SendNotification();
1040   application.Render();
1041
1042   // Check the size in the new frame
1043   DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
1044
1045   currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
1046   DALI_TEST_EQUALS(currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1047
1048   END_TEST;
1049 }
1050
1051 // SetSize(Vector2 size)
1052 int UtcDaliActorSetSize03(void)
1053 {
1054   TestApplication application;
1055
1056   Actor   actor = Actor::New();
1057   Vector3 vector(100.0f, 100.0f, 0.0f);
1058
1059   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
1060
1061   actor.SetProperty(Actor::Property::SIZE, Vector2(vector.x, vector.y));
1062
1063   // Immediately check the size after setting
1064   Vector3 currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
1065   DALI_TEST_EQUALS(currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1066
1067   // flush the queue and render once
1068   application.SendNotification();
1069   application.Render();
1070
1071   // Check the size in the new frame
1072   DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
1073
1074   currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
1075   DALI_TEST_EQUALS(currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1076
1077   END_TEST;
1078 }
1079
1080 // SetSize(Vector3 size)
1081 int UtcDaliActorSetSize04(void)
1082 {
1083   TestApplication application;
1084
1085   Actor   actor = Actor::New();
1086   Vector3 vector(100.0f, 100.0f, 100.0f);
1087
1088   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
1089
1090   actor.SetProperty(Actor::Property::SIZE, vector);
1091
1092   // Immediately check the size after setting
1093   Vector3 currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
1094   DALI_TEST_EQUALS(currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1095
1096   // flush the queue and render once
1097   application.SendNotification();
1098   application.Render();
1099
1100   // Check the size in the new frame
1101   DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
1102
1103   application.GetScene().Add(actor);
1104   actor.SetProperty(Actor::Property::SIZE, Vector3(0.1f, 0.2f, 0.3f));
1105
1106   // Immediately check the size after setting
1107   currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
1108   DALI_TEST_EQUALS(currentSize, Vector3(0.1f, 0.2f, 0.3f), Math::MACHINE_EPSILON_0, TEST_LOCATION);
1109
1110   // flush the queue and render once
1111   application.SendNotification();
1112   application.Render();
1113
1114   // Check the size in the new frame
1115   DALI_TEST_EQUALS(Vector3(0.1f, 0.2f, 0.3f), actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), TEST_LOCATION);
1116
1117   currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
1118   DALI_TEST_EQUALS(currentSize, Vector3(0.1f, 0.2f, 0.3f), Math::MACHINE_EPSILON_0, TEST_LOCATION);
1119
1120   application.GetScene().Remove(actor);
1121   END_TEST;
1122 }
1123
1124 int UtcDaliActorSetSizeIndividual(void)
1125 {
1126   TestApplication application;
1127
1128   Actor actor = Actor::New();
1129
1130   Vector3 vector(0.7f, 0.8f, 0.9f);
1131   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
1132
1133   actor.SetProperty(Actor::Property::SIZE_WIDTH, vector.width);
1134
1135   // Immediately check the width after setting
1136   float sizeWidth = actor.GetProperty(Actor::Property::SIZE_WIDTH).Get<float>();
1137   DALI_TEST_EQUALS(sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1138
1139   // flush the queue and render once
1140   application.SendNotification();
1141   application.Render();
1142
1143   // Check the width in the new frame
1144   DALI_TEST_EQUALS(vector.width, actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).width, TEST_LOCATION);
1145
1146   sizeWidth = actor.GetProperty(Actor::Property::SIZE_WIDTH).Get<float>();
1147   DALI_TEST_EQUALS(sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1148
1149   actor.SetProperty(Actor::Property::SIZE_HEIGHT, vector.height);
1150
1151   // Immediately check the height after setting
1152   float sizeHeight = actor.GetProperty(Actor::Property::SIZE_HEIGHT).Get<float>();
1153   DALI_TEST_EQUALS(sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1154
1155   // flush the queue and render once
1156   application.SendNotification();
1157   application.Render();
1158
1159   // Check the height in the new frame
1160   DALI_TEST_EQUALS(vector.height, actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).height, TEST_LOCATION);
1161
1162   sizeHeight = actor.GetProperty(Actor::Property::SIZE_HEIGHT).Get<float>();
1163   DALI_TEST_EQUALS(sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1164
1165   actor.SetProperty(Actor::Property::SIZE_DEPTH, vector.depth);
1166
1167   // Immediately check the depth after setting
1168   float sizeDepth = actor.GetProperty(Actor::Property::SIZE_DEPTH).Get<float>();
1169   DALI_TEST_EQUALS(sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1170
1171   // flush the queue and render once
1172   application.SendNotification();
1173   application.Render();
1174
1175   // Check the depth in the new frame
1176   DALI_TEST_EQUALS(vector.depth, actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).depth, TEST_LOCATION);
1177
1178   sizeDepth = actor.GetProperty(Actor::Property::SIZE_DEPTH).Get<float>();
1179   DALI_TEST_EQUALS(sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1180
1181   // Change the resize policy and check whether the size stays the same
1182   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1183
1184   sizeWidth = actor.GetProperty(Actor::Property::SIZE_WIDTH).Get<float>();
1185   DALI_TEST_EQUALS(sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1186
1187   sizeHeight = actor.GetProperty(Actor::Property::SIZE_HEIGHT).Get<float>();
1188   DALI_TEST_EQUALS(sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1189
1190   sizeDepth = actor.GetProperty(Actor::Property::SIZE_DEPTH).Get<float>();
1191   DALI_TEST_EQUALS(sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1192
1193   // Change the resize policy again and check whether the size stays the same
1194   actor.SetResizePolicy(ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS);
1195
1196   sizeWidth = actor.GetProperty(Actor::Property::SIZE_WIDTH).Get<float>();
1197   DALI_TEST_EQUALS(sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1198
1199   sizeHeight = actor.GetProperty(Actor::Property::SIZE_HEIGHT).Get<float>();
1200   DALI_TEST_EQUALS(sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1201
1202   sizeDepth = actor.GetProperty(Actor::Property::SIZE_DEPTH).Get<float>();
1203   DALI_TEST_EQUALS(sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1204
1205   END_TEST;
1206 }
1207
1208 int UtcDaliActorSetSizeIndividual02(void)
1209 {
1210   TestApplication application;
1211
1212   Actor actor = Actor::New();
1213   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1214   application.GetScene().Add(actor);
1215
1216   Vector3 vector(100.0f, 200.0f, 400.0f);
1217   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
1218
1219   actor.SetProperty(Actor::Property::SIZE_WIDTH, vector.width);
1220   DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::SIZE_WIDTH).Get<float>(), vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1221
1222   actor.SetProperty(Actor::Property::SIZE_HEIGHT, vector.height);
1223   DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::SIZE_HEIGHT).Get<float>(), vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1224
1225   actor.SetProperty(Actor::Property::SIZE_DEPTH, vector.depth);
1226   DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::SIZE_DEPTH).Get<float>(), vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION);
1227
1228   // flush the queue and render once
1229   application.SendNotification();
1230   application.Render();
1231
1232   // Check the width in the new frame
1233   DALI_TEST_EQUALS(vector.width, actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).width, TEST_LOCATION);
1234   DALI_TEST_EQUALS(vector.height, actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).height, TEST_LOCATION);
1235
1236   END_TEST;
1237 }
1238
1239 int UtcDaliActorGetCurrentSize(void)
1240 {
1241   TestApplication application;
1242
1243   Actor   actor = Actor::New();
1244   Vector3 vector(100.0f, 100.0f, 20.0f);
1245
1246   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
1247
1248   actor.SetProperty(Actor::Property::SIZE, vector);
1249
1250   // flush the queue and render once
1251   application.SendNotification();
1252   application.Render();
1253
1254   DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
1255   END_TEST;
1256 }
1257
1258 int UtcDaliActorGetNaturalSize(void)
1259 {
1260   TestApplication application;
1261
1262   Actor   actor = Actor::New();
1263   Vector3 vector(0.0f, 0.0f, 0.0f);
1264
1265   DALI_TEST_CHECK(actor.GetNaturalSize() == vector);
1266
1267   END_TEST;
1268 }
1269
1270 int UtcDaliActorGetCurrentSizeImmediate(void)
1271 {
1272   TestApplication application;
1273
1274   Actor   actor = Actor::New();
1275   Vector3 vector(100.0f, 100.0f, 20.0f);
1276
1277   DALI_TEST_CHECK(vector != actor.GetTargetSize());
1278   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
1279
1280   actor.SetProperty(Actor::Property::SIZE, vector);
1281
1282   DALI_TEST_CHECK(vector == actor.GetTargetSize());
1283   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
1284
1285   // flush the queue and render once
1286   application.SendNotification();
1287   application.Render();
1288
1289   DALI_TEST_CHECK(vector == actor.GetTargetSize());
1290   DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
1291
1292   // Animation
1293   // Build the animation
1294   const float   durationSeconds = 2.0f;
1295   Animation     animation       = Animation::New(durationSeconds);
1296   const Vector3 targetValue(10.0f, 20.0f, 30.0f);
1297   animation.AnimateTo(Property(actor, Actor::Property::SIZE), targetValue);
1298
1299   DALI_TEST_CHECK(actor.GetTargetSize() == vector);
1300
1301   application.GetScene().Add(actor);
1302
1303   // Start the animation
1304   animation.Play();
1305
1306   application.SendNotification();
1307   application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f));
1308
1309   DALI_TEST_CHECK(actor.GetTargetSize() == targetValue);
1310
1311   END_TEST;
1312 }
1313
1314 int UtcDaliActorCalculateScreenExtents(void)
1315 {
1316   TestApplication application;
1317
1318   Actor actor = Actor::New();
1319
1320   actor.SetProperty(Actor::Property::POSITION, Vector3(2.0f, 2.0f, 16.0f));
1321   actor.SetProperty(Actor::Property::SIZE, Vector3{1.0f, 1.0f, 1.0f});
1322
1323   application.SendNotification();
1324   application.Render();
1325
1326   auto expectedExtent = Rect<>{-0.5f, -0.5f, 1.0f, 1.0f};
1327   auto actualExtent   = DevelActor::CalculateScreenExtents(actor);
1328   DALI_TEST_EQUALS(expectedExtent.x, actualExtent.x, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
1329   DALI_TEST_EQUALS(expectedExtent.y, actualExtent.y, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
1330   DALI_TEST_EQUALS(expectedExtent.width, actualExtent.width, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
1331   DALI_TEST_EQUALS(expectedExtent.height, actualExtent.height, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
1332
1333   application.GetScene().Remove(actor);
1334   END_TEST;
1335 }
1336
1337 // SetPosition(float x, float y)
1338 int UtcDaliActorSetPosition01(void)
1339 {
1340   TestApplication application;
1341
1342   Actor actor = Actor::New();
1343
1344   // Set to random to start off with
1345   actor.SetProperty(Actor::Property::POSITION, Vector3(120.0f, 120.0f, 0.0f));
1346
1347   Vector3 vector(100.0f, 100.0f, 0.0f);
1348
1349   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
1350
1351   actor.SetProperty(Actor::Property::POSITION, Vector2(vector.x, vector.y));
1352   // flush the queue and render once
1353   application.SendNotification();
1354   application.Render();
1355   DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
1356
1357   application.GetScene().Add(actor);
1358   actor.SetProperty(Actor::Property::POSITION, Vector3(0.1f, 0.2f, 0.3f));
1359   // flush the queue and render once
1360   application.SendNotification();
1361   application.Render();
1362   DALI_TEST_EQUALS(Vector3(0.1f, 0.2f, 0.3f), actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
1363
1364   actor.SetProperty(Actor::Property::POSITION_X, 1.0f);
1365   actor.SetProperty(Actor::Property::POSITION_Y, 1.1f);
1366   actor.SetProperty(Actor::Property::POSITION_Z, 1.2f);
1367   // flush the queue and render once
1368   application.SendNotification();
1369   application.Render();
1370   DALI_TEST_EQUALS(Vector3(1.0f, 1.1f, 1.2f), actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
1371
1372   actor.TranslateBy(Vector3(0.1f, 0.1f, 0.1f));
1373   // flush the queue and render once
1374   application.SendNotification();
1375   application.Render();
1376   DALI_TEST_EQUALS(Vector3(1.1f, 1.2f, 1.3f), actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Math::MACHINE_EPSILON_10000, TEST_LOCATION);
1377
1378   application.GetScene().Remove(actor);
1379   END_TEST;
1380 }
1381
1382 // SetPosition(float x, float y, float z)
1383 int UtcDaliActorSetPosition02(void)
1384 {
1385   TestApplication application;
1386
1387   Actor actor = Actor::New();
1388
1389   // Set to random to start off with
1390   actor.SetProperty(Actor::Property::POSITION, Vector3(120.0f, 120.0f, 120.0f));
1391
1392   Vector3 vector(100.0f, 100.0f, 100.0f);
1393
1394   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
1395
1396   actor.SetProperty(Actor::Property::POSITION, Vector3(vector.x, vector.y, vector.z));
1397
1398   // flush the queue and render once
1399   application.SendNotification();
1400   application.Render();
1401
1402   DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
1403   END_TEST;
1404 }
1405
1406 // SetPosition(Vector3 position)
1407 int UtcDaliActorSetPosition03(void)
1408 {
1409   TestApplication application;
1410
1411   Actor actor = Actor::New();
1412
1413   // Set to random to start off with
1414   actor.SetProperty(Actor::Property::POSITION, Vector3(120.0f, 120.0f, 120.0f));
1415
1416   Vector3 vector(100.0f, 100.0f, 100.0f);
1417
1418   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
1419
1420   actor.SetProperty(Actor::Property::POSITION, vector);
1421
1422   // flush the queue and render once
1423   application.SendNotification();
1424   application.Render();
1425
1426   DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
1427   END_TEST;
1428 }
1429
1430 int UtcDaliActorSetX(void)
1431 {
1432   TestApplication application;
1433
1434   Actor actor = Actor::New();
1435
1436   Vector3 vector(100.0f, 0.0f, 0.0f);
1437
1438   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
1439
1440   actor.SetProperty(Actor::Property::POSITION_X, 100.0f);
1441
1442   // flush the queue and render once
1443   application.SendNotification();
1444   application.Render();
1445
1446   DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
1447   END_TEST;
1448 }
1449
1450 int UtcDaliActorSetY(void)
1451 {
1452   TestApplication application;
1453
1454   Actor actor = Actor::New();
1455
1456   Vector3 vector(0.0f, 100.0f, 0.0f);
1457
1458   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
1459
1460   actor.SetProperty(Actor::Property::POSITION_Y, 100.0f);
1461
1462   // flush the queue and render once
1463   application.SendNotification();
1464   application.Render();
1465
1466   DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
1467   END_TEST;
1468 }
1469
1470 int UtcDaliActorSetZ(void)
1471 {
1472   TestApplication application;
1473
1474   Actor actor = Actor::New();
1475
1476   Vector3 vector(0.0f, 0.0f, 100.0f);
1477
1478   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
1479
1480   actor.SetProperty(Actor::Property::POSITION_Z, 100.0f);
1481
1482   // flush the queue and render once
1483   application.SendNotification();
1484   application.Render();
1485
1486   DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
1487   END_TEST;
1488 }
1489
1490 int UtcDaliActorSetPositionProperties(void)
1491 {
1492   TestApplication application;
1493
1494   Actor actor = Actor::New();
1495
1496   Vector3 vector(0.7f, 0.8f, 0.9f);
1497   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
1498
1499   actor.SetProperty(Actor::Property::POSITION_X, vector.x);
1500   DALI_TEST_EQUALS(vector.x, actor.GetProperty<Vector3>(Actor::Property::POSITION).x, TEST_LOCATION);
1501   DALI_TEST_EQUALS(vector.x, actor.GetProperty<float>(Actor::Property::POSITION_X), TEST_LOCATION);
1502
1503   // flush the queue and render once
1504   application.SendNotification();
1505   application.Render();
1506
1507   DALI_TEST_EQUALS(vector.x, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).x, TEST_LOCATION);
1508   DALI_TEST_EQUALS(vector.x, actor.GetProperty<Vector3>(Actor::Property::POSITION).x, TEST_LOCATION);
1509   DALI_TEST_EQUALS(vector.x, actor.GetProperty<float>(Actor::Property::POSITION_X), TEST_LOCATION);
1510   DALI_TEST_EQUALS(vector.x, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).x, TEST_LOCATION);
1511   DALI_TEST_EQUALS(vector.x, actor.GetCurrentProperty<float>(Actor::Property::POSITION_X), TEST_LOCATION);
1512
1513   actor.SetProperty(Actor::Property::POSITION_Y, vector.y);
1514   DALI_TEST_EQUALS(vector.y, actor.GetProperty<Vector3>(Actor::Property::POSITION).y, TEST_LOCATION);
1515   DALI_TEST_EQUALS(vector.y, actor.GetProperty<float>(Actor::Property::POSITION_Y), TEST_LOCATION);
1516
1517   // flush the queue and render once
1518   application.SendNotification();
1519   application.Render();
1520
1521   DALI_TEST_EQUALS(vector.y, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).y, TEST_LOCATION);
1522   DALI_TEST_EQUALS(vector.y, actor.GetProperty<Vector3>(Actor::Property::POSITION).y, TEST_LOCATION);
1523   DALI_TEST_EQUALS(vector.y, actor.GetProperty<float>(Actor::Property::POSITION_Y), TEST_LOCATION);
1524   DALI_TEST_EQUALS(vector.y, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).y, TEST_LOCATION);
1525   DALI_TEST_EQUALS(vector.y, actor.GetCurrentProperty<float>(Actor::Property::POSITION_Y), TEST_LOCATION);
1526
1527   actor.SetProperty(Actor::Property::POSITION_Z, vector.z);
1528   DALI_TEST_EQUALS(vector.z, actor.GetProperty<Vector3>(Actor::Property::POSITION).z, TEST_LOCATION);
1529   DALI_TEST_EQUALS(vector.z, actor.GetProperty<float>(Actor::Property::POSITION_Z), TEST_LOCATION);
1530
1531   // flush the queue and render once
1532   application.SendNotification();
1533   application.Render();
1534
1535   DALI_TEST_EQUALS(vector.z, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).z, TEST_LOCATION);
1536   DALI_TEST_EQUALS(vector.z, actor.GetProperty<Vector3>(Actor::Property::POSITION).z, TEST_LOCATION);
1537   DALI_TEST_EQUALS(vector.z, actor.GetProperty<float>(Actor::Property::POSITION_Z), TEST_LOCATION);
1538   DALI_TEST_EQUALS(vector.z, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).z, TEST_LOCATION);
1539   DALI_TEST_EQUALS(vector.z, actor.GetCurrentProperty<float>(Actor::Property::POSITION_Z), TEST_LOCATION);
1540
1541   END_TEST;
1542 }
1543
1544 int UtcDaliActorTranslateBy(void)
1545 {
1546   TestApplication application;
1547
1548   Actor   actor = Actor::New();
1549   Vector3 vector(100.0f, 100.0f, 100.0f);
1550
1551   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
1552
1553   actor.SetProperty(Actor::Property::POSITION, vector);
1554
1555   // flush the queue and render once
1556   application.SendNotification();
1557   application.Render();
1558
1559   DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
1560
1561   actor.TranslateBy(vector);
1562
1563   // flush the queue and render once
1564   application.SendNotification();
1565   application.Render();
1566
1567   DALI_TEST_CHECK(vector * 2.0f == actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
1568   END_TEST;
1569 }
1570
1571 int UtcDaliActorGetCurrentPosition(void)
1572 {
1573   TestApplication application;
1574
1575   Actor   actor = Actor::New();
1576   Vector3 setVector(100.0f, 100.0f, 0.0f);
1577   actor.SetProperty(Actor::Property::POSITION, setVector);
1578
1579   // flush the queue and render once
1580   application.SendNotification();
1581   application.Render();
1582
1583   DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION) == setVector);
1584   END_TEST;
1585 }
1586
1587 int UtcDaliActorGetCurrentWorldPosition(void)
1588 {
1589   TestApplication application;
1590
1591   Actor   parent = Actor::New();
1592   Vector3 parentPosition(1.0f, 2.0f, 3.0f);
1593   parent.SetProperty(Actor::Property::POSITION, parentPosition);
1594   parent.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1595   parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
1596   application.GetScene().Add(parent);
1597
1598   Actor child = Actor::New();
1599   child.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1600   child.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
1601   Vector3 childPosition(6.0f, 6.0f, 6.0f);
1602   child.SetProperty(Actor::Property::POSITION, childPosition);
1603   parent.Add(child);
1604
1605   // The actors should not have a world position yet
1606   DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3::ZERO, TEST_LOCATION);
1607   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3::ZERO, TEST_LOCATION);
1608
1609   application.SendNotification();
1610   application.Render(0);
1611
1612   DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::POSITION), parentPosition, TEST_LOCATION);
1613   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::POSITION), childPosition, TEST_LOCATION);
1614
1615   // The actors should have a world position now
1616   DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), parentPosition, TEST_LOCATION);
1617   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), parentPosition + childPosition, TEST_LOCATION);
1618   END_TEST;
1619 }
1620
1621 int UtcDaliActorSetInheritPosition(void)
1622 {
1623   tet_infoline("Testing Actor::SetInheritPosition");
1624   TestApplication application;
1625
1626   Actor   parent = Actor::New();
1627   Vector3 parentPosition(1.0f, 2.0f, 3.0f);
1628   parent.SetProperty(Actor::Property::POSITION, parentPosition);
1629   parent.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1630   parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
1631   application.GetScene().Add(parent);
1632
1633   Actor child = Actor::New();
1634   child.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1635   child.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
1636   Vector3 childPosition(10.0f, 11.0f, 12.0f);
1637   child.SetProperty(Actor::Property::POSITION, childPosition);
1638   parent.Add(child);
1639
1640   // The actors should not have a world position yet
1641   DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3::ZERO, TEST_LOCATION);
1642   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3::ZERO, TEST_LOCATION);
1643
1644   // first test default, which is to inherit position
1645   DALI_TEST_EQUALS(child.GetProperty<bool>(Actor::Property::INHERIT_POSITION), true, TEST_LOCATION);
1646   application.SendNotification();
1647   application.Render(0); // should only really call Update as Render is not required to update scene
1648   DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::POSITION), parentPosition, TEST_LOCATION);
1649   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::POSITION), childPosition, TEST_LOCATION);
1650   DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), parentPosition, TEST_LOCATION);
1651   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), parentPosition + childPosition, TEST_LOCATION);
1652
1653   //Change child position
1654   Vector3 childOffset(-1.0f, 1.0f, 0.0f);
1655   child.SetProperty(Actor::Property::POSITION, childOffset);
1656
1657   // Use local position as world postion
1658   child.SetProperty(Actor::Property::INHERIT_POSITION, false);
1659   DALI_TEST_EQUALS(child.GetProperty<bool>(Actor::Property::INHERIT_POSITION), false, TEST_LOCATION);
1660   application.SendNotification();
1661   application.Render(0); // should only really call Update as Render is not required to update scene
1662   DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::POSITION), parentPosition, TEST_LOCATION);
1663   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::POSITION), childOffset, TEST_LOCATION);
1664   DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), parentPosition, TEST_LOCATION);
1665   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), childOffset, TEST_LOCATION);
1666
1667   //Change back to inherit position from parent
1668   child.SetProperty(Actor::Property::INHERIT_POSITION, true);
1669   DALI_TEST_EQUALS(child.GetProperty<bool>(Actor::Property::INHERIT_POSITION), true, TEST_LOCATION);
1670   application.SendNotification();
1671   application.Render(0); // should only really call Update as Render is not required to update scene
1672   DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::POSITION), parentPosition, TEST_LOCATION);
1673   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::POSITION), childOffset, TEST_LOCATION);
1674   DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), parentPosition, TEST_LOCATION);
1675   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), parentPosition + childOffset, TEST_LOCATION);
1676   END_TEST;
1677 }
1678
1679 int UtcDaliActorInheritOpacity(void)
1680 {
1681   tet_infoline("Testing Actor::Inherit Opacity");
1682   TestApplication application;
1683
1684   Actor parent = Actor::New();
1685   Actor child  = Actor::New();
1686   parent.Add(child);
1687   application.GetScene().Add(parent);
1688
1689   DALI_TEST_EQUALS(parent.GetProperty(Actor::Property::COLOR_ALPHA).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION);
1690   DALI_TEST_EQUALS(child.GetProperty(Actor::Property::COLOR_ALPHA).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION);
1691
1692   // flush the queue and render once
1693   application.SendNotification();
1694   application.Render();
1695
1696   parent.SetProperty(Actor::Property::OPACITY, 0.1f);
1697
1698   DALI_TEST_EQUALS(parent.GetProperty(Actor::Property::COLOR_ALPHA).Get<float>(), 0.1f, 0.0001f, TEST_LOCATION);
1699   DALI_TEST_EQUALS(child.GetProperty(Actor::Property::COLOR_ALPHA).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION);
1700
1701   application.SendNotification();
1702   application.Render();
1703
1704   DALI_TEST_EQUALS(parent.GetProperty(Actor::Property::WORLD_COLOR).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION);
1705   DALI_TEST_EQUALS(parent.GetCurrentProperty(Actor::Property::COLOR_ALPHA).Get<float>(), 0.1f, 0.0001f, TEST_LOCATION);
1706   DALI_TEST_EQUALS(parent.GetCurrentProperty(Actor::Property::WORLD_COLOR).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION);
1707   DALI_TEST_EQUALS(child.GetProperty(Actor::Property::WORLD_COLOR).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION);
1708   DALI_TEST_EQUALS(child.GetCurrentProperty(Actor::Property::WORLD_COLOR).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION);
1709   DALI_TEST_EQUALS(child.GetCurrentProperty(Actor::Property::COLOR_ALPHA).Get<float>(), 1.f, 0.0001f, TEST_LOCATION);
1710
1711   END_TEST;
1712 }
1713
1714 // SetOrientation(float angleRadians, Vector3 axis)
1715 int UtcDaliActorSetOrientation01(void)
1716 {
1717   TestApplication application;
1718
1719   Quaternion rotation(Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
1720   Actor      actor = Actor::New();
1721
1722   actor.SetProperty(Actor::Property::ORIENTATION, rotation);
1723
1724   // flush the queue and render once
1725   application.SendNotification();
1726   application.Render();
1727
1728   DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
1729   END_TEST;
1730 }
1731
1732 int UtcDaliActorSetOrientation02(void)
1733 {
1734   TestApplication application;
1735
1736   Actor actor = Actor::New();
1737
1738   Radian  angle(0.785f);
1739   Vector3 axis(1.0f, 1.0f, 0.0f);
1740
1741   actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(angle, axis));
1742   Quaternion rotation(angle, axis);
1743   // flush the queue and render once
1744   application.SendNotification();
1745   application.Render();
1746   DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
1747
1748   application.GetScene().Add(actor);
1749   actor.RotateBy(Degree(360), axis);
1750   DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
1751
1752   actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Degree(0), Vector3(1.0f, 0.0f, 0.0f)));
1753   Quaternion result(Radian(0), Vector3(1.0f, 0.0f, 0.0f));
1754   // flush the queue and render once
1755   application.SendNotification();
1756   application.Render();
1757   DALI_TEST_EQUALS(result, actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
1758
1759   actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(angle, axis));
1760   // flush the queue and render once
1761   application.SendNotification();
1762   application.Render();
1763   DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
1764
1765   application.GetScene().Remove(actor);
1766   END_TEST;
1767 }
1768
1769 // SetOrientation(float angleRadians, Vector3 axis)
1770 int UtcDaliActorSetOrientationProperty(void)
1771 {
1772   TestApplication application;
1773
1774   Quaternion rotation(Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
1775   Actor      actor = Actor::New();
1776
1777   actor.SetProperty(Actor::Property::ORIENTATION, rotation);
1778   DALI_TEST_EQUALS(rotation, actor.GetProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
1779
1780   // flush the queue and render once
1781   application.SendNotification();
1782   application.Render();
1783
1784   DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
1785   DALI_TEST_EQUALS(rotation, actor.GetProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
1786   DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
1787   END_TEST;
1788 }
1789
1790 // RotateBy(float angleRadians, Vector3 axis)
1791 int UtcDaliActorRotateBy01(void)
1792 {
1793   TestApplication application;
1794
1795   Actor actor = Actor::New();
1796
1797   Radian angle(M_PI * 0.25f);
1798   actor.RotateBy((angle), Vector3::ZAXIS);
1799   // flush the queue and render once
1800   application.SendNotification();
1801   application.Render();
1802   DALI_TEST_EQUALS(Quaternion(angle, Vector3::ZAXIS), actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
1803
1804   application.GetScene().Add(actor);
1805
1806   actor.RotateBy(angle, Vector3::ZAXIS);
1807   // flush the queue and render once
1808   application.SendNotification();
1809   application.Render();
1810   DALI_TEST_EQUALS(Quaternion(angle * 2.0f, Vector3::ZAXIS), actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
1811
1812   application.GetScene().Remove(actor);
1813   END_TEST;
1814 }
1815
1816 // RotateBy(Quaternion relativeRotation)
1817 int UtcDaliActorRotateBy02(void)
1818 {
1819   TestApplication application;
1820
1821   Actor actor = Actor::New();
1822
1823   Radian     angle(M_PI * 0.25f);
1824   Quaternion rotation(angle, Vector3::ZAXIS);
1825   actor.RotateBy(rotation);
1826   // flush the queue and render once
1827   application.SendNotification();
1828   application.Render();
1829   DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
1830
1831   actor.RotateBy(rotation);
1832   // flush the queue and render once
1833   application.SendNotification();
1834   application.Render();
1835   DALI_TEST_EQUALS(Quaternion(angle * 2.0f, Vector3::ZAXIS), actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
1836   END_TEST;
1837 }
1838
1839 int UtcDaliActorGetCurrentOrientation(void)
1840 {
1841   TestApplication application;
1842   Actor           actor = Actor::New();
1843
1844   Quaternion rotation(Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
1845   actor.SetProperty(Actor::Property::ORIENTATION, rotation);
1846   // flush the queue and render once
1847   application.SendNotification();
1848   application.Render();
1849   DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
1850   END_TEST;
1851 }
1852
1853 int UtcDaliActorGetCurrentWorldOrientation(void)
1854 {
1855   tet_infoline("Testing Actor::GetCurrentWorldRotation");
1856   TestApplication application;
1857
1858   Actor      parent = Actor::New();
1859   Radian     rotationAngle(Degree(90.0f));
1860   Quaternion rotation(rotationAngle, Vector3::YAXIS);
1861   parent.SetProperty(Actor::Property::ORIENTATION, rotation);
1862   application.GetScene().Add(parent);
1863
1864   Actor child = Actor::New();
1865   child.SetProperty(Actor::Property::ORIENTATION, rotation);
1866   parent.Add(child);
1867
1868   // The actors should not have a world rotation yet
1869   DALI_TEST_EQUALS(parent.GetCurrentProperty<Quaternion>(Actor::Property::WORLD_ORIENTATION), Quaternion(Radian(0.0f), Vector3::YAXIS), 0.001, TEST_LOCATION);
1870   DALI_TEST_EQUALS(child.GetCurrentProperty<Quaternion>(Actor::Property::WORLD_ORIENTATION), Quaternion(Radian(0.0f), Vector3::YAXIS), 0.001, TEST_LOCATION);
1871
1872   application.SendNotification();
1873   application.Render(0);
1874
1875   DALI_TEST_EQUALS(parent.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, 0.001, TEST_LOCATION);
1876   DALI_TEST_EQUALS(child.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, 0.001, TEST_LOCATION);
1877
1878   // The actors should have a world rotation now
1879   DALI_TEST_EQUALS(parent.GetCurrentProperty<Quaternion>(Actor::Property::WORLD_ORIENTATION), Quaternion(rotationAngle, Vector3::YAXIS), 0.001, TEST_LOCATION);
1880   DALI_TEST_EQUALS(child.GetCurrentProperty<Quaternion>(Actor::Property::WORLD_ORIENTATION), Quaternion(rotationAngle * 2.0f, Vector3::YAXIS), 0.001, TEST_LOCATION);
1881
1882   // turn off child rotation inheritance
1883   child.SetProperty(Actor::Property::INHERIT_ORIENTATION, false);
1884   DALI_TEST_EQUALS(child.GetProperty<bool>(Actor::Property::INHERIT_ORIENTATION), false, TEST_LOCATION);
1885   application.SendNotification();
1886   application.Render(0);
1887
1888   // The actors should have a world rotation now
1889   DALI_TEST_EQUALS(parent.GetCurrentProperty<Quaternion>(Actor::Property::WORLD_ORIENTATION), Quaternion(rotationAngle, Vector3::YAXIS), 0.001, TEST_LOCATION);
1890   DALI_TEST_EQUALS(child.GetCurrentProperty<Quaternion>(Actor::Property::WORLD_ORIENTATION), rotation, 0.001, TEST_LOCATION);
1891   END_TEST;
1892 }
1893
1894 // SetScale(float scale)
1895 int UtcDaliActorSetScale01(void)
1896 {
1897   TestApplication application;
1898
1899   Actor actor = Actor::New();
1900
1901   // Set to random value first -.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) asserts if called before SetScale()
1902   actor.SetProperty(Actor::Property::SCALE, 0.25f);
1903
1904   Vector3 scale(10.0f, 10.0f, 10.0f);
1905   DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE) != scale);
1906
1907   actor.SetProperty(Actor::Property::SCALE, scale.x);
1908
1909   // flush the queue and render once
1910   application.SendNotification();
1911   application.Render();
1912
1913   DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE) == scale);
1914   END_TEST;
1915 }
1916
1917 // SetScale(float scaleX, float scaleY, float scaleZ)
1918 int UtcDaliActorSetScale02(void)
1919 {
1920   TestApplication application;
1921   Vector3         scale(10.0f, 10.0f, 10.0f);
1922
1923   Actor actor = Actor::New();
1924
1925   // Set to random value first -.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) asserts if called before SetScale()
1926   actor.SetProperty(Actor::Property::SCALE, Vector3(12.0f, 1.0f, 2.0f));
1927
1928   DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE) != scale);
1929
1930   actor.SetProperty(Actor::Property::SCALE, Vector3(scale.x, scale.y, scale.z));
1931   // flush the queue and render once
1932   application.SendNotification();
1933   application.Render();
1934   DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE) == scale);
1935
1936   // add to stage and test
1937   application.GetScene().Add(actor);
1938   actor.SetProperty(Actor::Property::SCALE, Vector3(2.0f, 2.0f, 2.0f));
1939   // flush the queue and render once
1940   application.SendNotification();
1941   application.Render();
1942   DALI_TEST_EQUALS(Vector3(2.0f, 2.0f, 2.0f), actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), 0.001, TEST_LOCATION);
1943
1944   application.GetScene().Remove(actor);
1945
1946   END_TEST;
1947 }
1948
1949 // SetScale(Vector3 scale)
1950 int UtcDaliActorSetScale03(void)
1951 {
1952   TestApplication application;
1953   Vector3         scale(10.0f, 10.0f, 10.0f);
1954
1955   Actor actor = Actor::New();
1956
1957   // Set to random value first -.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) asserts if called before SetScale()
1958   actor.SetProperty(Actor::Property::SCALE, Vector3(12.0f, 1.0f, 2.0f));
1959
1960   DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE) != scale);
1961
1962   actor.SetProperty(Actor::Property::SCALE, scale);
1963
1964   // flush the queue and render once
1965   application.SendNotification();
1966   application.Render();
1967
1968   DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE) == scale);
1969   END_TEST;
1970 }
1971
1972 int UtcDaliActorSetScaleIndividual(void)
1973 {
1974   TestApplication application;
1975
1976   Actor actor = Actor::New();
1977
1978   Vector3 vector(0.7f, 0.8f, 0.9f);
1979   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE));
1980
1981   actor.SetProperty(Actor::Property::SCALE_X, vector.x);
1982   DALI_TEST_EQUALS(vector.x, actor.GetProperty<float>(Actor::Property::SCALE_X), TEST_LOCATION);
1983
1984   // flush the queue and render once
1985   application.SendNotification();
1986   application.Render();
1987
1988   DALI_TEST_EQUALS(vector.x, actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE).x, TEST_LOCATION);
1989   DALI_TEST_EQUALS(vector.x, actor.GetProperty<float>(Actor::Property::SCALE_X), TEST_LOCATION);
1990   DALI_TEST_EQUALS(vector.x, actor.GetCurrentProperty<float>(Actor::Property::SCALE_X), TEST_LOCATION);
1991
1992   actor.SetProperty(Actor::Property::SCALE_Y, vector.y);
1993   DALI_TEST_EQUALS(vector.y, actor.GetProperty<float>(Actor::Property::SCALE_Y), TEST_LOCATION);
1994
1995   // flush the queue and render once
1996   application.SendNotification();
1997   application.Render();
1998
1999   DALI_TEST_EQUALS(vector.y, actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE).y, TEST_LOCATION);
2000   DALI_TEST_EQUALS(vector.y, actor.GetProperty<float>(Actor::Property::SCALE_Y), TEST_LOCATION);
2001   DALI_TEST_EQUALS(vector.y, actor.GetCurrentProperty<float>(Actor::Property::SCALE_Y), TEST_LOCATION);
2002
2003   actor.SetProperty(Actor::Property::SCALE_Z, vector.z);
2004   DALI_TEST_EQUALS(vector.z, actor.GetProperty<float>(Actor::Property::SCALE_Z), TEST_LOCATION);
2005
2006   // flush the queue and render once
2007   application.SendNotification();
2008   application.Render();
2009
2010   DALI_TEST_EQUALS(vector.z, actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE).z, TEST_LOCATION);
2011   DALI_TEST_EQUALS(vector.z, actor.GetProperty<float>(Actor::Property::SCALE_Z), TEST_LOCATION);
2012   DALI_TEST_EQUALS(vector.z, actor.GetCurrentProperty<float>(Actor::Property::SCALE_Z), TEST_LOCATION);
2013
2014   DALI_TEST_EQUALS(vector, actor.GetProperty<Vector3>(Actor::Property::SCALE), TEST_LOCATION);
2015   DALI_TEST_EQUALS(vector, actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), TEST_LOCATION);
2016
2017   END_TEST;
2018 }
2019
2020 int UtcDaliActorScaleBy(void)
2021 {
2022   TestApplication application;
2023   Actor           actor = Actor::New();
2024   Vector3         vector(100.0f, 100.0f, 100.0f);
2025
2026   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE));
2027
2028   actor.SetProperty(Actor::Property::SCALE, vector);
2029
2030   // flush the queue and render once
2031   application.SendNotification();
2032   application.Render();
2033
2034   DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE));
2035
2036   actor.ScaleBy(vector);
2037
2038   // flush the queue and render once
2039   application.SendNotification();
2040   application.Render();
2041
2042   DALI_TEST_CHECK(vector * 100.0f == actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE));
2043   END_TEST;
2044 }
2045
2046 int UtcDaliActorGetCurrentScale(void)
2047 {
2048   TestApplication application;
2049   Vector3         scale(12.0f, 1.0f, 2.0f);
2050
2051   Actor actor = Actor::New();
2052
2053   actor.SetProperty(Actor::Property::SCALE, scale);
2054
2055   // flush the queue and render once
2056   application.SendNotification();
2057   application.Render();
2058
2059   DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE) == scale);
2060   END_TEST;
2061 }
2062
2063 int UtcDaliActorGetCurrentWorldScale(void)
2064 {
2065   TestApplication application;
2066
2067   Actor   parent = Actor::New();
2068   Vector3 parentScale(1.0f, 2.0f, 3.0f);
2069   parent.SetProperty(Actor::Property::SCALE, parentScale);
2070   application.GetScene().Add(parent);
2071
2072   Actor   child = Actor::New();
2073   Vector3 childScale(2.0f, 2.0f, 2.0f);
2074   child.SetProperty(Actor::Property::SCALE, childScale);
2075   parent.Add(child);
2076
2077   // The actors should not have a scale yet
2078   DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::SCALE), Vector3::ONE, TEST_LOCATION);
2079   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::SCALE), Vector3::ONE, TEST_LOCATION);
2080
2081   // The actors should not have a world scale yet
2082   DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::WORLD_SCALE), Vector3::ONE, TEST_LOCATION);
2083   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_SCALE), Vector3::ONE, TEST_LOCATION);
2084
2085   application.SendNotification();
2086   application.Render(0);
2087
2088   DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::SCALE), parentScale, TEST_LOCATION);
2089   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::SCALE), childScale, TEST_LOCATION);
2090
2091   // The actors should have a world scale now
2092   DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::WORLD_SCALE), parentScale, TEST_LOCATION);
2093   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_SCALE), parentScale * childScale, TEST_LOCATION);
2094   END_TEST;
2095 }
2096
2097 int UtcDaliActorInheritScale(void)
2098 {
2099   tet_infoline("Testing Actor::SetInheritScale");
2100   TestApplication application;
2101
2102   Actor   parent = Actor::New();
2103   Vector3 parentScale(1.0f, 2.0f, 3.0f);
2104   parent.SetProperty(Actor::Property::SCALE, parentScale);
2105   application.GetScene().Add(parent);
2106
2107   Actor   child = Actor::New();
2108   Vector3 childScale(2.0f, 2.0f, 2.0f);
2109   child.SetProperty(Actor::Property::SCALE, childScale);
2110   parent.Add(child);
2111
2112   application.SendNotification();
2113   application.Render(0);
2114
2115   DALI_TEST_EQUALS(child.GetProperty<bool>(Actor::Property::INHERIT_SCALE), true, TEST_LOCATION);
2116   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_SCALE), parentScale * childScale, TEST_LOCATION);
2117
2118   child.SetProperty(Actor::Property::INHERIT_SCALE, false);
2119   DALI_TEST_EQUALS(child.GetProperty<bool>(Actor::Property::INHERIT_SCALE), false, TEST_LOCATION);
2120
2121   application.SendNotification();
2122   application.Render(0);
2123
2124   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_SCALE), childScale, TEST_LOCATION);
2125   END_TEST;
2126 }
2127
2128 int UtcDaliActorSetVisible(void)
2129 {
2130   TestApplication application;
2131
2132   Actor actor = Actor::New();
2133   actor.SetProperty(Actor::Property::VISIBLE, false);
2134   // flush the queue and render once
2135   application.SendNotification();
2136   application.Render();
2137   DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE) == false);
2138
2139   actor.SetProperty(Actor::Property::VISIBLE, true);
2140   // flush the queue and render once
2141   application.SendNotification();
2142   application.Render();
2143   DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE) == true);
2144
2145   // put actor on stage
2146   application.GetScene().Add(actor);
2147   actor.SetProperty(Actor::Property::VISIBLE, false);
2148   // flush the queue and render once
2149   application.SendNotification();
2150   application.Render();
2151   DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE) == false);
2152   END_TEST;
2153 }
2154
2155 int UtcDaliActorIsVisible(void)
2156 {
2157   TestApplication application;
2158
2159   Actor actor = Actor::New();
2160
2161   DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE) == true);
2162   END_TEST;
2163 }
2164
2165 int UtcDaliActorSetOpacity(void)
2166 {
2167   TestApplication application;
2168
2169   Actor actor = Actor::New();
2170   // initial opacity is 1
2171   DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::OPACITY), 1.0f, TEST_LOCATION);
2172
2173   actor.SetProperty(Actor::Property::OPACITY, 0.4f);
2174   // flush the queue and render once
2175   application.SendNotification();
2176   application.Render();
2177   DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::OPACITY), 0.4f, TEST_LOCATION);
2178
2179   // change opacity, actor is on stage to change is not immediate
2180   actor.SetProperty(Actor::Property::OPACITY, actor.GetCurrentProperty<float>(Actor::Property::OPACITY) + 0.1f);
2181   // flush the queue and render once
2182   application.SendNotification();
2183   application.Render();
2184   DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::OPACITY), 0.5f, TEST_LOCATION);
2185
2186   // put actor on stage
2187   application.GetScene().Add(actor);
2188
2189   // change opacity, actor is on stage to change is not immediate
2190   actor.SetProperty(Actor::Property::OPACITY, 0.9f);
2191   DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::OPACITY), 0.5f, TEST_LOCATION);
2192   // flush the queue and render once
2193   application.SendNotification();
2194   application.Render();
2195   DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::OPACITY), 0.9f, TEST_LOCATION);
2196
2197   // change opacity, actor is on stage to change is not immediate
2198   actor.SetProperty(Actor::Property::OPACITY, actor.GetCurrentProperty<float>(Actor::Property::OPACITY) - 0.9f);
2199   // flush the queue and render once
2200   application.SendNotification();
2201   application.Render();
2202   DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::OPACITY), 0.0f, TEST_LOCATION);
2203   END_TEST;
2204 }
2205
2206 int UtcDaliActorGetCurrentOpacity(void)
2207 {
2208   TestApplication application;
2209
2210   Actor actor = Actor::New();
2211   DALI_TEST_CHECK(actor.GetCurrentProperty<float>(Actor::Property::OPACITY) != 0.5f);
2212
2213   actor.SetProperty(Actor::Property::OPACITY, 0.5f);
2214   // flush the queue and render once
2215   application.SendNotification();
2216   application.Render();
2217   DALI_TEST_CHECK(actor.GetCurrentProperty<float>(Actor::Property::OPACITY) == 0.5f);
2218   END_TEST;
2219 }
2220
2221 int UtcDaliActorSetSensitive(void)
2222 {
2223   TestApplication application;
2224   Actor           actor = Actor::New();
2225
2226   bool sensitive = !actor.GetProperty<bool>(Actor::Property::SENSITIVE);
2227
2228   actor.SetProperty(Actor::Property::SENSITIVE, sensitive);
2229
2230   DALI_TEST_CHECK(sensitive == actor.GetProperty<bool>(Actor::Property::SENSITIVE));
2231   END_TEST;
2232 }
2233
2234 int UtcDaliActorIsSensitive(void)
2235 {
2236   TestApplication application;
2237   Actor           actor = Actor::New();
2238   actor.SetProperty(Actor::Property::SENSITIVE, false);
2239
2240   DALI_TEST_CHECK(false == actor.GetProperty<bool>(Actor::Property::SENSITIVE));
2241   END_TEST;
2242 }
2243
2244 int UtcDaliActorSetColor(void)
2245 {
2246   TestApplication application;
2247   Actor           actor = Actor::New();
2248   Vector4         color(1.0f, 1.0f, 1.0f, 0.5f);
2249
2250   DALI_TEST_CHECK(color != actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR));
2251
2252   actor.SetProperty(Actor::Property::COLOR, color);
2253   // flush the queue and render once
2254   application.SendNotification();
2255   application.Render();
2256   DALI_TEST_CHECK(color == actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR));
2257
2258   actor.SetProperty(Actor::Property::COLOR, actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR) + Vector4(-0.4f, -0.5f, -0.6f, -0.4f));
2259   // flush the queue and render once
2260   application.SendNotification();
2261   application.Render();
2262   DALI_TEST_EQUALS(Vector4(0.6f, 0.5f, 0.4f, 0.1f), actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), TEST_LOCATION);
2263
2264   application.GetScene().Add(actor);
2265   actor.SetProperty(Actor::Property::COLOR, color);
2266   // flush the queue and render once
2267   application.SendNotification();
2268   application.Render();
2269   DALI_TEST_EQUALS(color, actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), TEST_LOCATION);
2270
2271   actor.SetProperty(Actor::Property::COLOR, actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR) + Vector4(1.1f, 1.1f, 1.1f, 1.1f));
2272   // flush the queue and render once
2273   application.SendNotification();
2274   application.Render();
2275   // Actor color is not clamped
2276   DALI_TEST_EQUALS(Vector4(2.1f, 2.1f, 2.1f, 1.6f), actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), TEST_LOCATION);
2277   // world color is clamped
2278   DALI_TEST_EQUALS(Vector4(1.0f, 1.0f, 1.0f, 1.0f), actor.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR), TEST_LOCATION);
2279
2280   actor.SetProperty(Actor::Property::COLOR, color);
2281   DALI_TEST_EQUALS(color, actor.GetProperty<Vector4>(Actor::Property::COLOR), TEST_LOCATION);
2282
2283   Vector3 newColor(1.0f, 0.0f, 0.0f);
2284   actor.SetProperty(Actor::Property::COLOR, newColor);
2285   DALI_TEST_EQUALS(Vector4(newColor.r, newColor.g, newColor.b, 1.0f), actor.GetProperty<Vector4>(Actor::Property::COLOR), TEST_LOCATION);
2286
2287   application.GetScene().Remove(actor);
2288   END_TEST;
2289 }
2290
2291 int UtcDaliActorSetColorIndividual(void)
2292 {
2293   TestApplication application;
2294
2295   Actor actor = Actor::New();
2296
2297   Vector4 vector(0.7f, 0.8f, 0.9f, 0.6f);
2298   DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR));
2299
2300   actor.SetProperty(Actor::Property::COLOR_RED, vector.r);
2301   DALI_TEST_EQUALS(vector.r, actor.GetProperty<float>(Actor::Property::COLOR_RED), TEST_LOCATION);
2302
2303   // flush the queue and render once
2304   application.SendNotification();
2305   application.Render();
2306
2307   DALI_TEST_EQUALS(vector.r, actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).r, TEST_LOCATION);
2308   DALI_TEST_EQUALS(vector.r, actor.GetProperty<float>(Actor::Property::COLOR_RED), TEST_LOCATION);
2309   DALI_TEST_EQUALS(vector.r, actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), TEST_LOCATION);
2310
2311   actor.SetProperty(Actor::Property::COLOR_GREEN, vector.g);
2312   DALI_TEST_EQUALS(vector.g, actor.GetProperty<float>(Actor::Property::COLOR_GREEN), TEST_LOCATION);
2313
2314   // flush the queue and render once
2315   application.SendNotification();
2316   application.Render();
2317
2318   DALI_TEST_EQUALS(vector.g, actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).g, TEST_LOCATION);
2319   DALI_TEST_EQUALS(vector.g, actor.GetProperty<float>(Actor::Property::COLOR_GREEN), TEST_LOCATION);
2320   DALI_TEST_EQUALS(vector.g, actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), TEST_LOCATION);
2321
2322   actor.SetProperty(Actor::Property::COLOR_BLUE, vector.b);
2323   DALI_TEST_EQUALS(vector.b, actor.GetProperty<float>(Actor::Property::COLOR_BLUE), TEST_LOCATION);
2324
2325   // flush the queue and render once
2326   application.SendNotification();
2327   application.Render();
2328
2329   DALI_TEST_EQUALS(vector.b, actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).b, TEST_LOCATION);
2330   DALI_TEST_EQUALS(vector.b, actor.GetProperty<float>(Actor::Property::COLOR_BLUE), TEST_LOCATION);
2331   DALI_TEST_EQUALS(vector.b, actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), TEST_LOCATION);
2332
2333   actor.SetProperty(Actor::Property::COLOR_ALPHA, vector.a);
2334   DALI_TEST_EQUALS(vector.a, actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), TEST_LOCATION);
2335
2336   // flush the queue and render once
2337   application.SendNotification();
2338   application.Render();
2339
2340   DALI_TEST_EQUALS(vector.a, actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, TEST_LOCATION);
2341   DALI_TEST_EQUALS(vector.a, actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), TEST_LOCATION);
2342   DALI_TEST_EQUALS(vector.a, actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), TEST_LOCATION);
2343
2344   DALI_TEST_EQUALS(vector, actor.GetProperty<Vector4>(Actor::Property::COLOR), TEST_LOCATION);
2345   DALI_TEST_EQUALS(vector, actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), TEST_LOCATION);
2346
2347   actor.SetProperty(Actor::Property::OPACITY, 0.2f);
2348
2349   // flush the queue and render once
2350   application.SendNotification();
2351   application.Render();
2352
2353   DALI_TEST_EQUALS(0.2f, actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, TEST_LOCATION);
2354
2355   END_TEST;
2356 }
2357
2358 int UtcDaliActorGetCurrentColor(void)
2359 {
2360   TestApplication application;
2361   Actor           actor = Actor::New();
2362   Vector4         color(1.0f, 1.0f, 1.0f, 0.5f);
2363
2364   actor.SetProperty(Actor::Property::COLOR, color);
2365   // flush the queue and render once
2366   application.SendNotification();
2367   application.Render();
2368   DALI_TEST_CHECK(color == actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR));
2369   END_TEST;
2370 }
2371
2372 int UtcDaliActorGetCurrentWorldColor(void)
2373 {
2374   tet_infoline("Actor::GetCurrentWorldColor");
2375   TestApplication application;
2376
2377   Actor   parent = Actor::New();
2378   Vector4 parentColor(1.0f, 0.5f, 0.0f, 0.8f);
2379   parent.SetProperty(Actor::Property::COLOR, parentColor);
2380   application.GetScene().Add(parent);
2381
2382   Actor   child = Actor::New();
2383   Vector4 childColor(0.5f, 0.6f, 0.5f, 1.0f);
2384   child.SetProperty(Actor::Property::COLOR, childColor);
2385   parent.Add(child);
2386
2387   DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
2388   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
2389
2390   // verify the default color mode
2391   DALI_TEST_EQUALS(USE_OWN_MULTIPLY_PARENT_ALPHA, child.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), TEST_LOCATION);
2392
2393   // The actors should not have a world color yet
2394   DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR), Color::WHITE, TEST_LOCATION);
2395   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR), Color::WHITE, TEST_LOCATION);
2396
2397   application.SendNotification();
2398   application.Render(0);
2399
2400   DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector4>(Actor::Property::COLOR), parentColor, TEST_LOCATION);
2401   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector4>(Actor::Property::COLOR), childColor, TEST_LOCATION);
2402
2403   // The actors should have a world color now
2404   DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR), parentColor, TEST_LOCATION);
2405   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR), Vector4(childColor.r, childColor.g, childColor.b, childColor.a * parentColor.a), TEST_LOCATION);
2406
2407   // use own color
2408   child.SetProperty(Actor::Property::COLOR_MODE, USE_OWN_COLOR);
2409   application.SendNotification();
2410   application.Render(0);
2411   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR), childColor, TEST_LOCATION);
2412
2413   // use parent color
2414   child.SetProperty(Actor::Property::COLOR_MODE, USE_PARENT_COLOR);
2415   application.SendNotification();
2416   application.Render(0);
2417   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector4>(Actor::Property::COLOR), childColor, TEST_LOCATION);
2418   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR), parentColor, TEST_LOCATION);
2419
2420   // use parent alpha
2421   child.SetProperty(Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_ALPHA);
2422   application.SendNotification();
2423   application.Render(0);
2424   Vector4 expectedColor(childColor);
2425   expectedColor.a *= parentColor.a;
2426   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector4>(Actor::Property::COLOR), childColor, TEST_LOCATION);
2427   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR), expectedColor, TEST_LOCATION);
2428   END_TEST;
2429 }
2430
2431 int UtcDaliActorSetColorMode(void)
2432 {
2433   tet_infoline("Actor::SetColorMode");
2434   TestApplication application;
2435   Actor           actor = Actor::New();
2436   Actor           child = Actor::New();
2437   actor.Add(child);
2438
2439   actor.SetProperty(Actor::Property::COLOR_MODE, USE_OWN_COLOR);
2440   DALI_TEST_EQUALS(USE_OWN_COLOR, actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), TEST_LOCATION);
2441
2442   actor.SetProperty(Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_COLOR);
2443   DALI_TEST_EQUALS(USE_OWN_MULTIPLY_PARENT_COLOR, actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), TEST_LOCATION);
2444
2445   actor.SetProperty(Actor::Property::COLOR_MODE, USE_PARENT_COLOR);
2446   DALI_TEST_EQUALS(USE_PARENT_COLOR, actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), TEST_LOCATION);
2447
2448   actor.SetProperty(Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_ALPHA);
2449   DALI_TEST_EQUALS(USE_OWN_MULTIPLY_PARENT_ALPHA, actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), TEST_LOCATION);
2450   END_TEST;
2451 }
2452
2453 int UtcDaliActorScreenToLocal(void)
2454 {
2455   TestApplication application;
2456   Actor           actor = Actor::New();
2457   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2458   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
2459   actor.SetProperty(Actor::Property::POSITION, Vector2(10.0f, 10.0f));
2460   application.GetScene().Add(actor);
2461
2462   // flush the queue and render once
2463   application.SendNotification();
2464   application.Render();
2465
2466   float localX;
2467   float localY;
2468
2469   application.SendNotification();
2470   application.Render();
2471
2472   DALI_TEST_CHECK(actor.ScreenToLocal(localX, localY, 50.0f, 50.0f));
2473
2474   DALI_TEST_EQUALS(localX, 40.0f, 0.01f, TEST_LOCATION);
2475   DALI_TEST_EQUALS(localY, 40.0f, 0.01f, TEST_LOCATION);
2476   END_TEST;
2477 }
2478
2479 int UtcDaliActorSetLeaveRequired(void)
2480 {
2481   TestApplication application;
2482
2483   Actor actor = Actor::New();
2484
2485   actor.SetProperty(Actor::Property::LEAVE_REQUIRED, false);
2486   DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::LEAVE_REQUIRED) == false);
2487
2488   actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true);
2489   DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::LEAVE_REQUIRED) == true);
2490   END_TEST;
2491 }
2492
2493 int UtcDaliActorGetLeaveRequired(void)
2494 {
2495   TestApplication application;
2496
2497   Actor actor = Actor::New();
2498
2499   DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::LEAVE_REQUIRED) == false);
2500   END_TEST;
2501 }
2502
2503 int UtcDaliActorSetKeyboardFocusable(void)
2504 {
2505   TestApplication application;
2506
2507   Actor actor = Actor::New();
2508
2509   actor.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
2510   DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::KEYBOARD_FOCUSABLE) == true);
2511
2512   actor.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, false);
2513   DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::KEYBOARD_FOCUSABLE) == false);
2514   END_TEST;
2515 }
2516
2517 int UtcDaliActorIsKeyboardFocusable(void)
2518 {
2519   TestApplication application;
2520
2521   Actor actor = Actor::New();
2522
2523   DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::KEYBOARD_FOCUSABLE) == false);
2524   END_TEST;
2525 }
2526
2527 int UtcDaliActorRemoveConstraints(void)
2528 {
2529   tet_infoline(" UtcDaliActorRemoveConstraints");
2530   TestApplication application;
2531
2532   gTestConstraintCalled = false;
2533
2534   Actor actor = Actor::New();
2535
2536   Constraint constraint = Constraint::New<Vector4>(actor, Actor::Property::COLOR, TestConstraint());
2537   constraint.Apply();
2538   actor.RemoveConstraints();
2539
2540   DALI_TEST_CHECK(gTestConstraintCalled == false);
2541
2542   application.GetScene().Add(actor);
2543   constraint.Apply();
2544
2545   // flush the queue and render once
2546   application.SendNotification();
2547   application.Render();
2548
2549   actor.RemoveConstraints();
2550
2551   DALI_TEST_CHECK(gTestConstraintCalled == true);
2552   END_TEST;
2553 }
2554
2555 int UtcDaliActorRemoveConstraintTag(void)
2556 {
2557   tet_infoline(" UtcDaliActorRemoveConstraintTag");
2558   TestApplication application;
2559
2560   Actor actor = Actor::New();
2561
2562   // 1. Apply Constraint1 and Constraint2, and test...
2563   unsigned int result1 = 0u;
2564   unsigned int result2 = 0u;
2565
2566   unsigned   constraint1Tag = 1u;
2567   Constraint constraint1    = Constraint::New<Vector4>(actor, Actor::Property::COLOR, TestConstraintRef<Vector4>(result1, 1));
2568   constraint1.SetTag(constraint1Tag);
2569   constraint1.Apply();
2570
2571   unsigned   constraint2Tag = 2u;
2572   Constraint constraint2    = Constraint::New<Vector4>(actor, Actor::Property::COLOR, TestConstraintRef<Vector4>(result2, 2));
2573   constraint2.SetTag(constraint2Tag);
2574   constraint2.Apply();
2575
2576   application.GetScene().Add(actor);
2577   // flush the queue and render once
2578   application.SendNotification();
2579   application.Render();
2580
2581   DALI_TEST_EQUALS(result1, 1u, TEST_LOCATION);
2582   DALI_TEST_EQUALS(result2, 2u, TEST_LOCATION);
2583
2584   // 2. Remove Constraint1 and test...
2585   result1 = 0;
2586   result2 = 0;
2587   actor.RemoveConstraints(constraint1Tag);
2588   // make color property dirty, which will trigger constraints to be reapplied.
2589   actor.SetProperty(Actor::Property::COLOR, Color::WHITE);
2590   // flush the queue and render once
2591   application.SendNotification();
2592   application.Render();
2593
2594   DALI_TEST_EQUALS(result1, 0u, TEST_LOCATION); ///< constraint 1 should not apply now.
2595   DALI_TEST_EQUALS(result2, 2u, TEST_LOCATION);
2596
2597   // 3. Re-Apply Constraint1 and test...
2598   result1 = 0;
2599   result2 = 0;
2600   constraint1.Apply();
2601   // make color property dirty, which will trigger constraints to be reapplied.
2602   actor.SetProperty(Actor::Property::COLOR, Color::WHITE);
2603   // flush the queue and render once
2604   application.SendNotification();
2605   application.Render();
2606
2607   DALI_TEST_EQUALS(result1, 1u, TEST_LOCATION);
2608   DALI_TEST_EQUALS(result2, 2u, TEST_LOCATION);
2609
2610   // 2. Remove Constraint2 and test...
2611   result1 = 0;
2612   result2 = 0;
2613   actor.RemoveConstraints(constraint2Tag);
2614   // make color property dirty, which will trigger constraints to be reapplied.
2615   actor.SetProperty(Actor::Property::COLOR, Color::WHITE);
2616   // flush the queue and render once
2617   application.SendNotification();
2618   application.Render();
2619
2620   DALI_TEST_EQUALS(result1, 1u, TEST_LOCATION);
2621   DALI_TEST_EQUALS(result2, 0u, TEST_LOCATION); ///< constraint 2 should not apply now.
2622
2623   // 2. Remove Constraint1 as well and test...
2624   result1 = 0;
2625   result2 = 0;
2626   actor.RemoveConstraints(constraint1Tag);
2627   // make color property dirty, which will trigger constraints to be reapplied.
2628   actor.SetProperty(Actor::Property::COLOR, Color::WHITE);
2629   // flush the queue and render once
2630   application.SendNotification();
2631   application.Render();
2632
2633   DALI_TEST_EQUALS(result1, 0u, TEST_LOCATION); ///< constraint 1 should not apply now.
2634   DALI_TEST_EQUALS(result2, 0u, TEST_LOCATION); ///< constraint 2 should not apply now.
2635   END_TEST;
2636 }
2637
2638 int UtcDaliActorTouchedSignal(void)
2639 {
2640   TestApplication application;
2641
2642   ResetTouchCallbacks();
2643
2644   // get the root layer
2645   Actor actor = application.GetScene().GetRootLayer();
2646   DALI_TEST_CHECK(gTouchCallBackCalled == false);
2647
2648   application.SendNotification();
2649   application.Render();
2650
2651   // connect to its touch signal
2652   actor.TouchedSignal().Connect(TestTouchCallback);
2653
2654   // simulate a touch event in the middle of the screen
2655   Vector2                  touchPoint(application.GetScene().GetSize() * 0.5);
2656   Dali::Integration::Point point;
2657   point.SetDeviceId(1);
2658   point.SetState(PointState::DOWN);
2659   point.SetScreenPosition(Vector2(touchPoint.x, touchPoint.y));
2660   Dali::Integration::TouchEvent touchEvent;
2661   touchEvent.AddPoint(point);
2662   application.ProcessEvent(touchEvent);
2663
2664   DALI_TEST_CHECK(gTouchCallBackCalled == true);
2665   END_TEST;
2666 }
2667
2668 int UtcDaliActorHoveredSignal(void)
2669 {
2670   TestApplication application;
2671
2672   gHoverCallBackCalled = false;
2673
2674   // get the root layer
2675   Actor actor = application.GetScene().GetRootLayer();
2676   DALI_TEST_CHECK(gHoverCallBackCalled == false);
2677
2678   application.SendNotification();
2679   application.Render();
2680
2681   // connect to its hover signal
2682   actor.HoveredSignal().Connect(TestCallback3);
2683
2684   // simulate a hover event in the middle of the screen
2685   Vector2                  touchPoint(application.GetScene().GetSize() * 0.5);
2686   Dali::Integration::Point point;
2687   point.SetDeviceId(1);
2688   point.SetState(PointState::MOTION);
2689   point.SetScreenPosition(Vector2(touchPoint.x, touchPoint.y));
2690   Dali::Integration::HoverEvent hoverEvent;
2691   hoverEvent.AddPoint(point);
2692   application.ProcessEvent(hoverEvent);
2693
2694   DALI_TEST_CHECK(gHoverCallBackCalled == true);
2695   END_TEST;
2696 }
2697
2698 int UtcDaliActorOnOffSceneSignal(void)
2699 {
2700   tet_infoline("Testing Dali::Actor::OnSceneSignal() and OffSceneSignal()");
2701
2702   TestApplication application;
2703
2704   // clean test data
2705   gOnSceneCallBackCalled = gOffSceneCallBackCalled = 0;
2706   gActorNamesOnOffScene.clear();
2707
2708   Actor parent = Actor::New();
2709   parent.SetProperty(Actor::Property::NAME, "parent");
2710   parent.OnSceneSignal().Connect(OnSceneCallback);
2711   parent.OffSceneSignal().Connect(OffSceneCallback);
2712   // sanity check
2713   DALI_TEST_CHECK(gOnSceneCallBackCalled == 0);
2714   DALI_TEST_CHECK(gOffSceneCallBackCalled == 0);
2715
2716   // add parent to the scene
2717   application.GetScene().Add(parent);
2718   // onstage emitted, offstage not
2719   DALI_TEST_EQUALS(gOnSceneCallBackCalled, 1, TEST_LOCATION);
2720   DALI_TEST_EQUALS(gOffSceneCallBackCalled, 0, TEST_LOCATION);
2721   DALI_TEST_EQUALS("parent", gActorNamesOnOffScene[0], TEST_LOCATION);
2722
2723   // test adding a child, should get onstage emitted
2724   // clean test data
2725   gOnSceneCallBackCalled = gOffSceneCallBackCalled = 0;
2726   gActorNamesOnOffScene.clear();
2727
2728   Actor child = Actor::New();
2729   child.SetProperty(Actor::Property::NAME, "child");
2730   child.OnSceneSignal().Connect(OnSceneCallback);
2731   child.OffSceneSignal().Connect(OffSceneCallback);
2732   parent.Add(child); // add child
2733   // onscene emitted, offscene not
2734   DALI_TEST_EQUALS(gOnSceneCallBackCalled, 1, TEST_LOCATION);
2735   DALI_TEST_EQUALS(gOffSceneCallBackCalled, 0, TEST_LOCATION);
2736   DALI_TEST_EQUALS("child", gActorNamesOnOffScene[0], TEST_LOCATION);
2737
2738   // test removing parent from the scene
2739   // clean test data
2740   gOnSceneCallBackCalled = gOffSceneCallBackCalled = 0;
2741   gActorNamesOnOffScene.clear();
2742
2743   application.GetScene().Remove(parent);
2744   // onscene not emitted, offscene is
2745   DALI_TEST_EQUALS(gOnSceneCallBackCalled, 0, TEST_LOCATION);
2746   DALI_TEST_EQUALS(gOffSceneCallBackCalled, 2, TEST_LOCATION);
2747   DALI_TEST_EQUALS("child", gActorNamesOnOffScene[0], TEST_LOCATION);
2748   DALI_TEST_EQUALS("parent", gActorNamesOnOffScene[1], TEST_LOCATION);
2749
2750   // test adding parent back to the scene
2751   // clean test data
2752   gOnSceneCallBackCalled = gOffSceneCallBackCalled = 0;
2753   gActorNamesOnOffScene.clear();
2754
2755   application.GetScene().Add(parent);
2756   // onscene emitted, offscene not
2757   DALI_TEST_EQUALS(gOnSceneCallBackCalled, 2, TEST_LOCATION);
2758   DALI_TEST_EQUALS(gOffSceneCallBackCalled, 0, TEST_LOCATION);
2759   DALI_TEST_EQUALS("parent", gActorNamesOnOffScene[0], TEST_LOCATION);
2760   DALI_TEST_EQUALS("child", gActorNamesOnOffScene[1], TEST_LOCATION);
2761
2762   // test removing child
2763   // clean test data
2764   gOnSceneCallBackCalled = gOffSceneCallBackCalled = 0;
2765   gActorNamesOnOffScene.clear();
2766
2767   parent.Remove(child);
2768   // onscene not emitted, offscene is
2769   DALI_TEST_EQUALS(gOnSceneCallBackCalled, 0, TEST_LOCATION);
2770   DALI_TEST_EQUALS(gOffSceneCallBackCalled, 1, TEST_LOCATION);
2771   DALI_TEST_EQUALS("child", gActorNamesOnOffScene[0], TEST_LOCATION);
2772
2773   // test removing parent
2774   // clean test data
2775   gOnSceneCallBackCalled = gOffSceneCallBackCalled = 0;
2776   gActorNamesOnOffScene.clear();
2777
2778   application.GetScene().Remove(parent);
2779   // onscene not emitted, offscene is
2780   DALI_TEST_EQUALS(gOnSceneCallBackCalled, 0, TEST_LOCATION);
2781   DALI_TEST_EQUALS(gOffSceneCallBackCalled, 1, TEST_LOCATION);
2782   DALI_TEST_EQUALS("parent", gActorNamesOnOffScene[0], TEST_LOCATION);
2783   END_TEST;
2784 }
2785
2786 int UtcDaliActorFindChildByName(void)
2787 {
2788   tet_infoline("Testing Dali::Actor::FindChildByName()");
2789   TestApplication application;
2790
2791   Actor parent = Actor::New();
2792   parent.SetProperty(Actor::Property::NAME, "parent");
2793   Actor first = Actor::New();
2794   first.SetProperty(Actor::Property::NAME, "first");
2795   Actor second = Actor::New();
2796   second.SetProperty(Actor::Property::NAME, "second");
2797
2798   parent.Add(first);
2799   first.Add(second);
2800
2801   Actor found = parent.FindChildByName("foo");
2802   DALI_TEST_CHECK(!found);
2803
2804   found = parent.FindChildByName("parent");
2805   DALI_TEST_CHECK(found == parent);
2806
2807   found = parent.FindChildByName("first");
2808   DALI_TEST_CHECK(found == first);
2809
2810   found = parent.FindChildByName("second");
2811   DALI_TEST_CHECK(found == second);
2812   END_TEST;
2813 }
2814
2815 int UtcDaliActorFindChildById(void)
2816 {
2817   tet_infoline("Testing Dali::Actor::UtcDaliActorFindChildById()");
2818   TestApplication application;
2819
2820   Actor parent = Actor::New();
2821   Actor first  = Actor::New();
2822   Actor second = Actor::New();
2823
2824   parent.Add(first);
2825   first.Add(second);
2826
2827   Actor found = parent.FindChildById(100000);
2828   DALI_TEST_CHECK(!found);
2829
2830   found = parent.FindChildById(parent.GetProperty<int>(Actor::Property::ID));
2831   DALI_TEST_CHECK(found == parent);
2832
2833   found = parent.FindChildById(first.GetProperty<int>(Actor::Property::ID));
2834   DALI_TEST_CHECK(found == first);
2835
2836   found = parent.FindChildById(second.GetProperty<int>(Actor::Property::ID));
2837   DALI_TEST_CHECK(found == second);
2838   END_TEST;
2839 }
2840
2841 int UtcDaliActorHitTest(void)
2842 {
2843   struct HitTestData
2844   {
2845   public:
2846     HitTestData(const Vector3& scale, const Vector2& touchPoint, bool result)
2847     : mScale(scale),
2848       mTouchPoint(touchPoint),
2849       mResult(result)
2850     {
2851     }
2852
2853     Vector3 mScale;
2854     Vector2 mTouchPoint;
2855     bool    mResult;
2856   };
2857
2858   TestApplication application;
2859   tet_infoline(" UtcDaliActorHitTest");
2860
2861   // Fill a vector with different hit tests.
2862   struct HitTestData* hitTestData[] = {
2863     //                    scale                     touch point           result
2864     new HitTestData(Vector3(100.f, 100.f, 1.f), Vector2(289.f, 400.f), true),  // touch point close to the right edge (inside)
2865     new HitTestData(Vector3(100.f, 100.f, 1.f), Vector2(291.f, 400.f), false), // touch point close to the right edge (outside)
2866     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.
2867     new HitTestData(Vector3(100.f, 100.f, 1.f), Vector2(200.f, 451.f), false), // touch point close to the down edge (outside)
2868     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.
2869     NULL,
2870   };
2871
2872   // get the root layer
2873   Actor actor = Actor::New();
2874   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
2875   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2876
2877   application.GetScene().Add(actor);
2878
2879   ResetTouchCallbacks();
2880
2881   unsigned int index = 0;
2882   while(NULL != hitTestData[index])
2883   {
2884     actor.SetProperty(Actor::Property::SIZE, Vector2(1.f, 1.f));
2885     actor.SetProperty(Actor::Property::SCALE, Vector3(hitTestData[index]->mScale.x, hitTestData[index]->mScale.y, hitTestData[index]->mScale.z));
2886
2887     // flush the queue and render once
2888     application.SendNotification();
2889     application.Render();
2890
2891     DALI_TEST_CHECK(!gTouchCallBackCalled);
2892
2893     // connect to its touch signal
2894     actor.TouchedSignal().Connect(TestTouchCallback);
2895
2896     Dali::Integration::Point point;
2897     point.SetState(PointState::DOWN);
2898     point.SetScreenPosition(Vector2(hitTestData[index]->mTouchPoint.x, hitTestData[index]->mTouchPoint.y));
2899     Dali::Integration::TouchEvent event;
2900     event.AddPoint(point);
2901
2902     // flush the queue and render once
2903     application.SendNotification();
2904     application.Render();
2905     application.ProcessEvent(event);
2906
2907     DALI_TEST_CHECK(gTouchCallBackCalled == hitTestData[index]->mResult);
2908
2909     if(gTouchCallBackCalled != hitTestData[index]->mResult)
2910       tet_printf("Test failed:\nScale %f %f %f\nTouchPoint %f, %f\nResult %d\n",
2911                  hitTestData[index]->mScale.x,
2912                  hitTestData[index]->mScale.y,
2913                  hitTestData[index]->mScale.z,
2914                  hitTestData[index]->mTouchPoint.x,
2915                  hitTestData[index]->mTouchPoint.y,
2916                  hitTestData[index]->mResult);
2917
2918     ResetTouchCallbacks();
2919     ++index;
2920   }
2921   END_TEST;
2922 }
2923
2924 int UtcDaliActorSetDrawMode(void)
2925 {
2926   TestApplication application;
2927   tet_infoline(" UtcDaliActorSetDrawModeOverlay");
2928
2929   Actor a = Actor::New();
2930
2931   application.GetScene().Add(a);
2932   application.SendNotification();
2933   application.Render(0);
2934   application.SendNotification();
2935   application.Render(1);
2936
2937   DALI_TEST_CHECK(DrawMode::NORMAL == a.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE)); // Ensure overlay is off by default
2938
2939   a.SetProperty(Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D);
2940   application.SendNotification();
2941   application.Render(1);
2942
2943   DALI_TEST_CHECK(DrawMode::OVERLAY_2D == a.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE)); // Check Actor is overlay
2944
2945   a.SetProperty(Actor::Property::DRAW_MODE, DrawMode::NORMAL);
2946   application.SendNotification();
2947   application.Render(1);
2948
2949   DALI_TEST_CHECK(DrawMode::NORMAL == a.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE)); // Check Actor is normal
2950   END_TEST;
2951 }
2952
2953 int UtcDaliActorSetDrawModeOverlayRender(void)
2954 {
2955   TestApplication application;
2956   tet_infoline(" UtcDaliActorSetDrawModeOverlayRender");
2957
2958   application.SendNotification();
2959   application.Render(1);
2960
2961   std::vector<GLuint> ids;
2962   ids.push_back(8);  // first rendered actor
2963   ids.push_back(9);  // second rendered actor
2964   ids.push_back(10); // third rendered actor
2965   application.GetGlAbstraction().SetNextTextureIds(ids);
2966
2967   Texture imageA = CreateTexture(TextureType::TEXTURE_2D, Pixel::Format::RGBA8888, 16, 16);
2968   Texture imageB = CreateTexture(TextureType::TEXTURE_2D, Pixel::Format::RGBA8888, 16, 16);
2969   Texture imageC = CreateTexture(TextureType::TEXTURE_2D, Pixel::Format::RGBA8888, 16, 16);
2970   Actor   a      = CreateRenderableActor(imageA);
2971   Actor   b      = CreateRenderableActor(imageB);
2972   Actor   c      = CreateRenderableActor(imageC);
2973
2974   application.SendNotification();
2975   application.Render(1);
2976
2977   //Textures are bound when first created. Clear bound textures vector
2978   application.GetGlAbstraction().ClearBoundTextures();
2979
2980   // Render a,b,c as regular non-overlays. so order will be:
2981   // a (8)
2982   // b (9)
2983   // c (10)
2984   application.GetScene().Add(a);
2985   application.GetScene().Add(b);
2986   application.GetScene().Add(c);
2987
2988   application.SendNotification();
2989   application.Render(1);
2990
2991   // Should be 3 textures changes.
2992   const std::vector<GLuint>&             boundTextures = application.GetGlAbstraction().GetBoundTextures(GL_TEXTURE0);
2993   typedef std::vector<GLuint>::size_type TextureSize;
2994   DALI_TEST_EQUALS(boundTextures.size(), static_cast<TextureSize>(3), TEST_LOCATION);
2995   if(boundTextures.size() == 3)
2996   {
2997     DALI_TEST_CHECK(boundTextures[0] == 8u);
2998     DALI_TEST_CHECK(boundTextures[1] == 9u);
2999     DALI_TEST_CHECK(boundTextures[2] == 10u);
3000   }
3001
3002   // Now texture ids have been set, we can monitor their render order.
3003   // render a as an overlay (last), so order will be:
3004   // b (9)
3005   // c (10)
3006   // a (8)
3007   a.SetProperty(Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D);
3008   application.GetGlAbstraction().ClearBoundTextures();
3009
3010   application.SendNotification();
3011   application.Render(1);
3012
3013   // Should be 3 texture changes.
3014   DALI_TEST_EQUALS(boundTextures.size(), static_cast<TextureSize>(3), TEST_LOCATION);
3015   if(boundTextures.size() == 3)
3016   {
3017     DALI_TEST_CHECK(boundTextures[0] == 9u);
3018     DALI_TEST_CHECK(boundTextures[1] == 10u);
3019     DALI_TEST_CHECK(boundTextures[2] == 8u);
3020   }
3021   END_TEST;
3022 }
3023
3024 int UtcDaliActorGetCurrentWorldMatrix(void)
3025 {
3026   TestApplication application;
3027   tet_infoline(" UtcDaliActorGetCurrentWorldMatrix");
3028
3029   Actor parent = Actor::New();
3030   parent.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3031   parent.SetProperty(Actor::Property::ANCHOR_POINT, 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.SetProperty(Actor::Property::POSITION, parentPosition);
3037   parent.SetProperty(Actor::Property::ORIENTATION, parentRotation);
3038   parent.SetProperty(Actor::Property::SCALE, parentScale);
3039   application.GetScene().Add(parent);
3040
3041   Actor child = Actor::New();
3042   child.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3043   Vector3    childPosition(0.0f, 0.0f, 100.0f);
3044   Radian     childRotationAngle(Degree(23.0f));
3045   Quaternion childRotation(childRotationAngle, Vector3::YAXIS);
3046   Vector3    childScale(2.0f, 2.0f, 2.0f);
3047   child.SetProperty(Actor::Property::POSITION, childPosition);
3048   child.SetProperty(Actor::Property::ORIENTATION, childRotation);
3049   child.SetProperty(Actor::Property::SCALE, childScale);
3050   parent.Add(child);
3051
3052   application.SendNotification();
3053   application.Render(0);
3054   application.Render();
3055   application.SendNotification();
3056
3057   Matrix parentMatrix(false);
3058   parentMatrix.SetTransformComponents(parentScale, parentRotation, parentPosition);
3059
3060   Matrix childMatrix(false);
3061   childMatrix.SetTransformComponents(childScale, childRotation, childPosition);
3062
3063   //Child matrix should be the composition of child and parent
3064   Matrix childWorldMatrix(false);
3065   Matrix::Multiply(childWorldMatrix, childMatrix, parentMatrix);
3066
3067   DALI_TEST_EQUALS(parent.GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX), parentMatrix, 0.001, TEST_LOCATION);
3068   DALI_TEST_EQUALS(child.GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX), childWorldMatrix, 0.001, TEST_LOCATION);
3069   END_TEST;
3070 }
3071
3072 int UtcDaliActorConstrainedToWorldMatrix(void)
3073 {
3074   TestApplication application;
3075   tet_infoline(" UtcDaliActorConstrainedToWorldMatrix");
3076
3077   Actor parent = Actor::New();
3078   parent.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3079   parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
3080   Vector3    parentPosition(10.0f, 20.0f, 30.0f);
3081   Radian     rotationAngle(Degree(85.0f));
3082   Quaternion parentRotation(rotationAngle, Vector3::ZAXIS);
3083   Vector3    parentScale(1.0f, 2.0f, 3.0f);
3084   parent.SetProperty(Actor::Property::POSITION, parentPosition);
3085   parent.SetProperty(Actor::Property::ORIENTATION, parentRotation);
3086   parent.SetProperty(Actor::Property::SCALE, parentScale);
3087   application.GetScene().Add(parent);
3088
3089   Actor child = Actor::New();
3090   child.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3091   Constraint posConstraint = Constraint::New<Vector3>(child, Actor::Property::POSITION, PositionComponentConstraint());
3092   posConstraint.AddSource(Source(parent, Actor::Property::WORLD_MATRIX));
3093   posConstraint.Apply();
3094
3095   application.GetScene().Add(child);
3096
3097   application.SendNotification();
3098   application.Render(0);
3099   application.Render();
3100   application.SendNotification();
3101
3102   Matrix parentMatrix(false);
3103   parentMatrix.SetTransformComponents(parentScale, parentRotation, parentPosition);
3104
3105   DALI_TEST_EQUALS(parent.GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX), parentMatrix, 0.001, TEST_LOCATION);
3106   DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::POSITION), parent.GetCurrentProperty<Vector3>(Actor::Property::POSITION), 0.001, TEST_LOCATION);
3107   END_TEST;
3108 }
3109
3110 int UtcDaliActorConstrainedToOrientation(void)
3111 {
3112   TestApplication application;
3113   tet_infoline(" UtcDaliActorConstrainedToOrientation");
3114
3115   Actor parent = Actor::New();
3116   parent.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3117   parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
3118   Vector3    parentPosition(10.0f, 20.0f, 30.0f);
3119   Radian     rotationAngle(Degree(85.0f));
3120   Quaternion parentRotation(rotationAngle, Vector3::ZAXIS);
3121   Vector3    parentScale(1.0f, 2.0f, 3.0f);
3122   parent.SetProperty(Actor::Property::POSITION, parentPosition);
3123   parent.SetProperty(Actor::Property::ORIENTATION, parentRotation);
3124   parent.SetProperty(Actor::Property::SCALE, parentScale);
3125   application.GetScene().Add(parent);
3126
3127   Actor child = Actor::New();
3128   child.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3129   Constraint posConstraint = Constraint::New<Quaternion>(child, Actor::Property::ORIENTATION, OrientationComponentConstraint());
3130   posConstraint.AddSource(Source(parent, Actor::Property::ORIENTATION));
3131   posConstraint.Apply();
3132
3133   application.GetScene().Add(child);
3134
3135   application.SendNotification();
3136   application.Render(0);
3137   application.Render();
3138   application.SendNotification();
3139
3140   DALI_TEST_EQUALS(child.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), parent.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
3141   END_TEST;
3142 }
3143
3144 int UtcDaliActorConstrainedToOpacity(void)
3145 {
3146   TestApplication application;
3147   tet_infoline(" UtcDaliActorConstrainedToOpacity");
3148
3149   Actor parent = Actor::New();
3150   parent.SetProperty(Actor::Property::OPACITY, 0.7f);
3151   application.GetScene().Add(parent);
3152
3153   Actor      child             = Actor::New();
3154   Constraint opacityConstraint = Constraint::New<float>(child, Actor::Property::OPACITY, EqualToConstraint());
3155   opacityConstraint.AddSource(Source(parent, Actor::Property::OPACITY));
3156   opacityConstraint.Apply();
3157
3158   application.GetScene().Add(child);
3159
3160   application.SendNotification();
3161   application.Render(0);
3162   application.Render();
3163   application.SendNotification();
3164
3165   DALI_TEST_EQUALS(child.GetCurrentProperty<float>(Actor::Property::OPACITY), parent.GetCurrentProperty<float>(Actor::Property::OPACITY), 0.001f, TEST_LOCATION);
3166
3167   parent.SetProperty(Actor::Property::OPACITY, 0.3f);
3168
3169   application.SendNotification();
3170   application.Render(0);
3171   application.Render();
3172   application.SendNotification();
3173
3174   DALI_TEST_EQUALS(child.GetCurrentProperty<float>(Actor::Property::OPACITY), parent.GetCurrentProperty<float>(Actor::Property::OPACITY), 0.001f, TEST_LOCATION);
3175
3176   END_TEST;
3177 }
3178
3179 int UtcDaliActorUnparent(void)
3180 {
3181   TestApplication application;
3182   tet_infoline(" UtcDaliActorUnparent");
3183
3184   Actor parent = Actor::New();
3185   application.GetScene().Add(parent);
3186
3187   Actor child = Actor::New();
3188
3189   DALI_TEST_EQUALS(parent.GetChildCount(), 0u, TEST_LOCATION);
3190   DALI_TEST_CHECK(!child.GetParent());
3191
3192   // Test that calling Unparent with no parent is a NOOP
3193   child.Unparent();
3194
3195   DALI_TEST_EQUALS(parent.GetChildCount(), 0u, TEST_LOCATION);
3196   DALI_TEST_CHECK(!child.GetParent());
3197
3198   // Test that Unparent works
3199   parent.Add(child);
3200
3201   DALI_TEST_EQUALS(parent.GetChildCount(), 1u, TEST_LOCATION);
3202   DALI_TEST_CHECK(parent == child.GetParent());
3203
3204   child.Unparent();
3205
3206   DALI_TEST_EQUALS(parent.GetChildCount(), 0u, TEST_LOCATION);
3207   DALI_TEST_CHECK(!child.GetParent());
3208
3209   // Test that UnparentAndReset works
3210   parent.Add(child);
3211
3212   DALI_TEST_EQUALS(parent.GetChildCount(), 1u, TEST_LOCATION);
3213   DALI_TEST_CHECK(parent == child.GetParent());
3214
3215   UnparentAndReset(child);
3216
3217   DALI_TEST_EQUALS(parent.GetChildCount(), 0u, TEST_LOCATION);
3218   DALI_TEST_CHECK(!child);
3219
3220   // Test that UnparentAndReset is a NOOP with empty handle
3221   UnparentAndReset(child);
3222
3223   DALI_TEST_CHECK(!child);
3224   END_TEST;
3225 }
3226
3227 int UtcDaliActorGetChildAt(void)
3228 {
3229   TestApplication application;
3230   tet_infoline(" UtcDaliActorGetChildAt");
3231
3232   Actor parent = Actor::New();
3233   application.GetScene().Add(parent);
3234
3235   Actor child0 = Actor::New();
3236   parent.Add(child0);
3237
3238   Actor child1 = Actor::New();
3239   parent.Add(child1);
3240
3241   Actor child2 = Actor::New();
3242   parent.Add(child2);
3243
3244   DALI_TEST_EQUALS(parent.GetChildAt(0), child0, TEST_LOCATION);
3245   DALI_TEST_EQUALS(parent.GetChildAt(1), child1, TEST_LOCATION);
3246   DALI_TEST_EQUALS(parent.GetChildAt(2), child2, TEST_LOCATION);
3247   END_TEST;
3248 }
3249
3250 int UtcDaliActorSetGetOverlay(void)
3251 {
3252   TestApplication application;
3253   tet_infoline(" UtcDaliActorSetGetOverlay");
3254
3255   Actor parent = Actor::New();
3256   parent.SetProperty(Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D);
3257   DALI_TEST_CHECK(parent.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE) == DrawMode::OVERLAY_2D);
3258   END_TEST;
3259 }
3260
3261 int UtcDaliActorCreateDestroy(void)
3262 {
3263   Actor* actor = new Actor;
3264   DALI_TEST_CHECK(actor);
3265   delete actor;
3266   END_TEST;
3267 }
3268
3269 namespace
3270 {
3271 struct PropertyStringIndex
3272 {
3273   const char* const     name;
3274   const Property::Index index;
3275   const Property::Type  type;
3276 };
3277
3278 const PropertyStringIndex PROPERTY_TABLE[] =
3279   {
3280     {"parentOrigin", Actor::Property::PARENT_ORIGIN, Property::VECTOR3},
3281     {"parentOriginX", Actor::Property::PARENT_ORIGIN_X, Property::FLOAT},
3282     {"parentOriginY", Actor::Property::PARENT_ORIGIN_Y, Property::FLOAT},
3283     {"parentOriginZ", Actor::Property::PARENT_ORIGIN_Z, Property::FLOAT},
3284     {"anchorPoint", Actor::Property::ANCHOR_POINT, Property::VECTOR3},
3285     {"anchorPointX", Actor::Property::ANCHOR_POINT_X, Property::FLOAT},
3286     {"anchorPointY", Actor::Property::ANCHOR_POINT_Y, Property::FLOAT},
3287     {"anchorPointZ", Actor::Property::ANCHOR_POINT_Z, Property::FLOAT},
3288     {"size", Actor::Property::SIZE, Property::VECTOR3},
3289     {"sizeWidth", Actor::Property::SIZE_WIDTH, Property::FLOAT},
3290     {"sizeHeight", Actor::Property::SIZE_HEIGHT, Property::FLOAT},
3291     {"sizeDepth", Actor::Property::SIZE_DEPTH, Property::FLOAT},
3292     {"position", Actor::Property::POSITION, Property::VECTOR3},
3293     {"positionX", Actor::Property::POSITION_X, Property::FLOAT},
3294     {"positionY", Actor::Property::POSITION_Y, Property::FLOAT},
3295     {"positionZ", Actor::Property::POSITION_Z, Property::FLOAT},
3296     {"worldPosition", Actor::Property::WORLD_POSITION, Property::VECTOR3},
3297     {"worldPositionX", Actor::Property::WORLD_POSITION_X, Property::FLOAT},
3298     {"worldPositionY", Actor::Property::WORLD_POSITION_Y, Property::FLOAT},
3299     {"worldPositionZ", Actor::Property::WORLD_POSITION_Z, Property::FLOAT},
3300     {"orientation", Actor::Property::ORIENTATION, Property::ROTATION},
3301     {"worldOrientation", Actor::Property::WORLD_ORIENTATION, Property::ROTATION},
3302     {"scale", Actor::Property::SCALE, Property::VECTOR3},
3303     {"scaleX", Actor::Property::SCALE_X, Property::FLOAT},
3304     {"scaleY", Actor::Property::SCALE_Y, Property::FLOAT},
3305     {"scaleZ", Actor::Property::SCALE_Z, Property::FLOAT},
3306     {"worldScale", Actor::Property::WORLD_SCALE, Property::VECTOR3},
3307     {"visible", Actor::Property::VISIBLE, Property::BOOLEAN},
3308     {"color", Actor::Property::COLOR, Property::VECTOR4},
3309     {"colorRed", Actor::Property::COLOR_RED, Property::FLOAT},
3310     {"colorGreen", Actor::Property::COLOR_GREEN, Property::FLOAT},
3311     {"colorBlue", Actor::Property::COLOR_BLUE, Property::FLOAT},
3312     {"colorAlpha", Actor::Property::COLOR_ALPHA, Property::FLOAT},
3313     {"worldColor", Actor::Property::WORLD_COLOR, Property::VECTOR4},
3314     {"worldMatrix", Actor::Property::WORLD_MATRIX, Property::MATRIX},
3315     {"name", Actor::Property::NAME, Property::STRING},
3316     {"sensitive", Actor::Property::SENSITIVE, Property::BOOLEAN},
3317     {"leaveRequired", Actor::Property::LEAVE_REQUIRED, Property::BOOLEAN},
3318     {"inheritOrientation", Actor::Property::INHERIT_ORIENTATION, Property::BOOLEAN},
3319     {"inheritScale", Actor::Property::INHERIT_SCALE, Property::BOOLEAN},
3320     {"colorMode", Actor::Property::COLOR_MODE, Property::INTEGER},
3321     {"drawMode", Actor::Property::DRAW_MODE, Property::INTEGER},
3322     {"sizeModeFactor", Actor::Property::SIZE_MODE_FACTOR, Property::VECTOR3},
3323     {"widthResizePolicy", Actor::Property::WIDTH_RESIZE_POLICY, Property::STRING},
3324     {"heightResizePolicy", Actor::Property::HEIGHT_RESIZE_POLICY, Property::STRING},
3325     {"sizeScalePolicy", Actor::Property::SIZE_SCALE_POLICY, Property::INTEGER},
3326     {"widthForHeight", Actor::Property::WIDTH_FOR_HEIGHT, Property::BOOLEAN},
3327     {"heightForWidth", Actor::Property::HEIGHT_FOR_WIDTH, Property::BOOLEAN},
3328     {"padding", Actor::Property::PADDING, Property::VECTOR4},
3329     {"minimumSize", Actor::Property::MINIMUM_SIZE, Property::VECTOR2},
3330     {"maximumSize", Actor::Property::MAXIMUM_SIZE, Property::VECTOR2},
3331     {"inheritPosition", Actor::Property::INHERIT_POSITION, Property::BOOLEAN},
3332     {"clippingMode", Actor::Property::CLIPPING_MODE, Property::STRING},
3333     {"opacity", Actor::Property::OPACITY, Property::FLOAT},
3334 };
3335 const unsigned int PROPERTY_TABLE_COUNT = sizeof(PROPERTY_TABLE) / sizeof(PROPERTY_TABLE[0]);
3336 } // unnamed namespace
3337
3338 int UtcDaliActorProperties(void)
3339 {
3340   TestApplication application;
3341
3342   Actor actor = Actor::New();
3343
3344   for(unsigned int i = 0; i < PROPERTY_TABLE_COUNT; ++i)
3345   {
3346     tet_printf("Checking %s == %d\n", PROPERTY_TABLE[i].name, PROPERTY_TABLE[i].index);
3347     DALI_TEST_EQUALS(actor.GetPropertyName(PROPERTY_TABLE[i].index), PROPERTY_TABLE[i].name, TEST_LOCATION);
3348     DALI_TEST_EQUALS(actor.GetPropertyIndex(PROPERTY_TABLE[i].name), PROPERTY_TABLE[i].index, TEST_LOCATION);
3349     DALI_TEST_EQUALS(actor.GetPropertyType(PROPERTY_TABLE[i].index), PROPERTY_TABLE[i].type, TEST_LOCATION);
3350   }
3351   END_TEST;
3352 }
3353
3354 int UtcDaliRelayoutProperties_ResizePolicies(void)
3355 {
3356   TestApplication application;
3357
3358   Actor actor = Actor::New();
3359
3360   // Defaults
3361   DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::WIDTH_RESIZE_POLICY).Get<std::string>(), "USE_NATURAL_SIZE", TEST_LOCATION);
3362   DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::HEIGHT_RESIZE_POLICY).Get<std::string>(), "USE_NATURAL_SIZE", TEST_LOCATION);
3363
3364   // Set resize policy for all dimensions
3365   actor.SetResizePolicy(ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS);
3366   for(unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i)
3367   {
3368     DALI_TEST_EQUALS(actor.GetResizePolicy(static_cast<Dimension::Type>(1 << i)), ResizePolicy::USE_NATURAL_SIZE, TEST_LOCATION);
3369   }
3370
3371   // Set individual dimensions
3372   const char* const widthPolicy  = "FILL_TO_PARENT";
3373   const char* const heightPolicy = "FIXED";
3374
3375   actor.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, widthPolicy);
3376   actor.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, heightPolicy);
3377
3378   DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::WIDTH_RESIZE_POLICY).Get<std::string>(), widthPolicy, TEST_LOCATION);
3379   DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::HEIGHT_RESIZE_POLICY).Get<std::string>(), heightPolicy, TEST_LOCATION);
3380
3381   // Set individual dimensions using enums
3382   ResizePolicy::Type widthPolicyEnum  = ResizePolicy::USE_ASSIGNED_SIZE;
3383   ResizePolicy::Type heightPolicyEnum = ResizePolicy::SIZE_RELATIVE_TO_PARENT;
3384
3385   actor.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, widthPolicyEnum);
3386   actor.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, heightPolicyEnum);
3387
3388   DALI_TEST_EQUALS(static_cast<int>(actor.GetResizePolicy(Dimension::WIDTH)), static_cast<int>(widthPolicyEnum), TEST_LOCATION);
3389   DALI_TEST_EQUALS(static_cast<int>(actor.GetResizePolicy(Dimension::HEIGHT)), static_cast<int>(heightPolicyEnum), TEST_LOCATION);
3390
3391   END_TEST;
3392 }
3393
3394 int UtcDaliRelayoutProperties_SizeScalePolicy(void)
3395 {
3396   TestApplication application;
3397
3398   Actor actor = Actor::New();
3399
3400   // Defaults
3401   DALI_TEST_EQUALS(actor.GetProperty<SizeScalePolicy::Type>(Actor::Property::SIZE_SCALE_POLICY), SizeScalePolicy::USE_SIZE_SET, TEST_LOCATION);
3402
3403   SizeScalePolicy::Type policy = SizeScalePolicy::FILL_WITH_ASPECT_RATIO;
3404   actor.SetProperty(Actor::Property::SIZE_SCALE_POLICY, policy);
3405   DALI_TEST_EQUALS(actor.GetProperty<SizeScalePolicy::Type>(Actor::Property::SIZE_SCALE_POLICY), policy, TEST_LOCATION);
3406
3407   // Set
3408   const SizeScalePolicy::Type policy1 = SizeScalePolicy::FIT_WITH_ASPECT_RATIO;
3409   const SizeScalePolicy::Type policy2 = SizeScalePolicy::FILL_WITH_ASPECT_RATIO;
3410
3411   actor.SetProperty(Actor::Property::SIZE_SCALE_POLICY, policy1);
3412   DALI_TEST_EQUALS(actor.GetProperty<SizeScalePolicy::Type>(Actor::Property::SIZE_SCALE_POLICY), policy1, TEST_LOCATION);
3413
3414   actor.SetProperty(Actor::Property::SIZE_SCALE_POLICY, policy2);
3415   DALI_TEST_EQUALS(actor.GetProperty<SizeScalePolicy::Type>(Actor::Property::SIZE_SCALE_POLICY), policy2, TEST_LOCATION);
3416
3417   END_TEST;
3418 }
3419
3420 int UtcDaliRelayoutProperties_SizeModeFactor(void)
3421 {
3422   TestApplication application;
3423
3424   Actor actor = Actor::New();
3425
3426   // Defaults
3427   DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::SIZE_MODE_FACTOR).Get<Vector3>(), Vector3(1.0f, 1.0f, 1.0f), TEST_LOCATION);
3428   DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SIZE_MODE_FACTOR), Vector3(1.0f, 1.0f, 1.0f), TEST_LOCATION);
3429
3430   Vector3 sizeMode(1.0f, 2.0f, 3.0f);
3431   actor.SetProperty(Actor::Property::SIZE_MODE_FACTOR, sizeMode);
3432   DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SIZE_MODE_FACTOR), sizeMode, TEST_LOCATION);
3433
3434   // Set
3435   Vector3 sizeMode1(2.0f, 3.0f, 4.0f);
3436
3437   actor.SetProperty(Actor::Property::SIZE_MODE_FACTOR, sizeMode1);
3438   DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::SIZE_MODE_FACTOR).Get<Vector3>(), sizeMode1, TEST_LOCATION);
3439
3440   END_TEST;
3441 }
3442
3443 int UtcDaliRelayoutProperties_DimensionDependency(void)
3444 {
3445   TestApplication application;
3446
3447   Actor actor = Actor::New();
3448
3449   // Defaults
3450   DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::WIDTH_FOR_HEIGHT).Get<bool>(), false, TEST_LOCATION);
3451   DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::HEIGHT_FOR_WIDTH).Get<bool>(), false, TEST_LOCATION);
3452
3453   // Set
3454   actor.SetProperty(Actor::Property::WIDTH_FOR_HEIGHT, true);
3455   DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::WIDTH_FOR_HEIGHT).Get<bool>(), true, TEST_LOCATION);
3456
3457   actor.SetProperty(Actor::Property::HEIGHT_FOR_WIDTH, true);
3458   DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::HEIGHT_FOR_WIDTH).Get<bool>(), true, TEST_LOCATION);
3459
3460   // Test setting another resize policy
3461   actor.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FIXED");
3462   DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::WIDTH_FOR_HEIGHT).Get<bool>(), false, TEST_LOCATION);
3463
3464   END_TEST;
3465 }
3466
3467 int UtcDaliRelayoutProperties_Padding(void)
3468 {
3469   TestApplication application;
3470
3471   Actor actor = Actor::New();
3472
3473   // Data
3474   Vector4 padding(1.0f, 2.0f, 3.0f, 4.0f);
3475
3476   // PADDING
3477   actor.SetProperty(Actor::Property::PADDING, padding);
3478   Vector4 paddingResult = actor.GetProperty(Actor::Property::PADDING).Get<Vector4>();
3479
3480   DALI_TEST_EQUALS(paddingResult, padding, Math::MACHINE_EPSILON_0, TEST_LOCATION);
3481
3482   END_TEST;
3483 }
3484
3485 int UtcDaliRelayoutProperties_MinimumMaximumSize(void)
3486 {
3487   TestApplication application;
3488
3489   Actor actor = Actor::New();
3490
3491   // Data
3492   Vector2 minSize(1.0f, 2.0f);
3493
3494   actor.SetProperty(Actor::Property::MINIMUM_SIZE, minSize);
3495   Vector2 resultMin = actor.GetProperty(Actor::Property::MINIMUM_SIZE).Get<Vector2>();
3496
3497   DALI_TEST_EQUALS(resultMin, minSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
3498
3499   Vector2 maxSize(3.0f, 4.0f);
3500
3501   actor.SetProperty(Actor::Property::MAXIMUM_SIZE, maxSize);
3502   Vector2 resultMax = actor.GetProperty(Actor::Property::MAXIMUM_SIZE).Get<Vector2>();
3503
3504   DALI_TEST_EQUALS(resultMax, maxSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
3505
3506   END_TEST;
3507 }
3508
3509 int UtcDaliActorGetHeightForWidth(void)
3510 {
3511   TestApplication application;
3512
3513   Actor actor = Actor::New();
3514
3515   DALI_TEST_EQUALS(actor.GetHeightForWidth(1.0f), 1.0f, TEST_LOCATION);
3516
3517   END_TEST;
3518 }
3519
3520 int UtcDaliActorGetWidthForHeight(void)
3521 {
3522   TestApplication application;
3523
3524   Actor actor = Actor::New();
3525
3526   DALI_TEST_EQUALS(actor.GetWidthForHeight(1.0f), 1.0f, TEST_LOCATION);
3527
3528   END_TEST;
3529 }
3530
3531 int UtcDaliActorGetRelayoutSize(void)
3532 {
3533   TestApplication application;
3534
3535   Actor actor = Actor::New();
3536
3537   // Add actor to stage
3538   application.GetScene().Add(actor);
3539
3540   DALI_TEST_EQUALS(actor.GetRelayoutSize(Dimension::WIDTH), 0.0f, TEST_LOCATION);
3541
3542   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::WIDTH);
3543   actor.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 0.0f));
3544
3545   // Flush the queue and render once
3546   application.SendNotification();
3547   application.Render();
3548
3549   DALI_TEST_EQUALS(actor.GetRelayoutSize(Dimension::WIDTH), 1.0f, TEST_LOCATION);
3550
3551   END_TEST;
3552 }
3553
3554 int UtcDaliActorSetPadding(void)
3555 {
3556   TestApplication application;
3557
3558   Actor actor = Actor::New();
3559
3560   Padding padding;
3561   padding = actor.GetProperty<Vector4>(Actor::Property::PADDING);
3562
3563   DALI_TEST_EQUALS(padding.left, 0.0f, TEST_LOCATION);
3564   DALI_TEST_EQUALS(padding.right, 0.0f, TEST_LOCATION);
3565   DALI_TEST_EQUALS(padding.bottom, 0.0f, TEST_LOCATION);
3566   DALI_TEST_EQUALS(padding.top, 0.0f, TEST_LOCATION);
3567
3568   Padding padding2(1.0f, 2.0f, 3.0f, 4.0f);
3569   actor.SetProperty(Actor::Property::PADDING, padding2);
3570
3571   padding = actor.GetProperty<Vector4>(Actor::Property::PADDING);
3572
3573   DALI_TEST_EQUALS(padding.left, padding2.left, TEST_LOCATION);
3574   DALI_TEST_EQUALS(padding.right, padding2.right, TEST_LOCATION);
3575   DALI_TEST_EQUALS(padding.bottom, padding2.bottom, TEST_LOCATION);
3576   DALI_TEST_EQUALS(padding.top, padding2.top, TEST_LOCATION);
3577
3578   END_TEST;
3579 }
3580
3581 int UtcDaliActorSetMinimumSize(void)
3582 {
3583   TestApplication application;
3584
3585   Actor actor = Actor::New();
3586
3587   Vector2 size = actor.GetProperty<Vector2>(Actor::Property::MINIMUM_SIZE);
3588
3589   DALI_TEST_EQUALS(size.width, 0.0f, TEST_LOCATION);
3590   DALI_TEST_EQUALS(size.height, 0.0f, TEST_LOCATION);
3591
3592   Vector2 size2(1.0f, 2.0f);
3593   actor.SetProperty(Actor::Property::MINIMUM_SIZE, size2);
3594
3595   size = actor.GetProperty<Vector2>(Actor::Property::MINIMUM_SIZE);
3596
3597   DALI_TEST_EQUALS(size.width, size2.width, TEST_LOCATION);
3598   DALI_TEST_EQUALS(size.height, size2.height, TEST_LOCATION);
3599
3600   END_TEST;
3601 }
3602
3603 int UtcDaliActorSetMaximumSize(void)
3604 {
3605   TestApplication application;
3606
3607   Actor actor = Actor::New();
3608
3609   Vector2 size = actor.GetProperty<Vector2>(Actor::Property::MAXIMUM_SIZE);
3610
3611   DALI_TEST_EQUALS(size.width, FLT_MAX, TEST_LOCATION);
3612   DALI_TEST_EQUALS(size.height, FLT_MAX, TEST_LOCATION);
3613
3614   Vector2 size2(1.0f, 2.0f);
3615   actor.SetProperty(Actor::Property::MAXIMUM_SIZE, size2);
3616
3617   size = actor.GetProperty<Vector2>(Actor::Property::MAXIMUM_SIZE);
3618
3619   DALI_TEST_EQUALS(size.width, size2.width, TEST_LOCATION);
3620   DALI_TEST_EQUALS(size.height, size2.height, TEST_LOCATION);
3621
3622   END_TEST;
3623 }
3624
3625 int UtcDaliActorOnRelayoutSignal(void)
3626 {
3627   tet_infoline("Testing Dali::Actor::OnRelayoutSignal()");
3628
3629   TestApplication application;
3630
3631   // Clean test data
3632   gOnRelayoutCallBackCalled = false;
3633   gActorNamesRelayout.clear();
3634
3635   Actor actor = Actor::New();
3636   actor.SetProperty(Actor::Property::NAME, "actor");
3637   actor.OnRelayoutSignal().Connect(OnRelayoutCallback);
3638
3639   // Sanity check
3640   DALI_TEST_CHECK(!gOnRelayoutCallBackCalled);
3641
3642   // Add actor to stage
3643   application.GetScene().Add(actor);
3644
3645   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
3646   actor.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 2.0));
3647
3648   // Flush the queue and render once
3649   application.SendNotification();
3650   application.Render();
3651
3652   // OnRelayout emitted
3653   DALI_TEST_EQUALS(gOnRelayoutCallBackCalled, true, TEST_LOCATION);
3654   DALI_TEST_EQUALS("actor", gActorNamesRelayout[0], TEST_LOCATION);
3655
3656   END_TEST;
3657 }
3658
3659 int UtcDaliActorGetHierachyDepth(void)
3660 {
3661   TestApplication application;
3662   tet_infoline("Testing Dali::Actor::GetHierarchyDepth()");
3663
3664   /* Build tree of actors:
3665    *
3666    *                      Depth
3667    *
3668    *       A (parent)       1
3669    *      / \
3670    *     B   C              2`
3671    *    / \   \
3672    *   D   E   F            3
3673    *
3674    * GetHierarchyDepth should return 1 for A, 2 for B and C, and 3 for D, E and F.
3675    */
3676   Integration::Scene stage(application.GetScene());
3677
3678   Actor actorA = Actor::New();
3679   Actor actorB = Actor::New();
3680   Actor actorC = Actor::New();
3681   Actor actorD = Actor::New();
3682   Actor actorE = Actor::New();
3683   Actor actorF = Actor::New();
3684
3685   //Test that root actor has depth equal 0
3686   DALI_TEST_EQUALS(0, stage.GetRootLayer().GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3687
3688   //Test actors return depth -1 when not connected to the tree
3689   DALI_TEST_EQUALS(-1, actorA.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3690   DALI_TEST_EQUALS(-1, actorB.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3691   DALI_TEST_EQUALS(-1, actorC.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3692   DALI_TEST_EQUALS(-1, actorD.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3693   DALI_TEST_EQUALS(-1, actorE.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3694   DALI_TEST_EQUALS(-1, actorF.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3695
3696   //Create the hierarchy
3697   stage.Add(actorA);
3698   actorA.Add(actorB);
3699   actorA.Add(actorC);
3700   actorB.Add(actorD);
3701   actorB.Add(actorE);
3702   actorC.Add(actorF);
3703
3704   //Test actors return correct depth
3705   DALI_TEST_EQUALS(1, actorA.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3706   DALI_TEST_EQUALS(2, actorB.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3707   DALI_TEST_EQUALS(2, actorC.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3708   DALI_TEST_EQUALS(3, actorD.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3709   DALI_TEST_EQUALS(3, actorE.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3710   DALI_TEST_EQUALS(3, actorF.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3711
3712   //Removing actorB from the hierarchy. actorB, actorD and actorE should now have depth equal -1
3713   actorA.Remove(actorB);
3714
3715   DALI_TEST_EQUALS(-1, actorB.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3716   DALI_TEST_EQUALS(-1, actorD.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3717   DALI_TEST_EQUALS(-1, actorE.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3718
3719   //Removing actorA from the stage. All actors should have depth equal -1
3720   stage.Remove(actorA);
3721
3722   DALI_TEST_EQUALS(-1, actorA.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3723   DALI_TEST_EQUALS(-1, actorB.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3724   DALI_TEST_EQUALS(-1, actorC.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3725   DALI_TEST_EQUALS(-1, actorD.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3726   DALI_TEST_EQUALS(-1, actorE.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3727   DALI_TEST_EQUALS(-1, actorF.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
3728
3729   END_TEST;
3730 }
3731
3732 int UtcDaliActorAnchorPointPropertyAsString(void)
3733 {
3734   TestApplication application;
3735
3736   Actor actor = Actor::New();
3737
3738   actor.SetProperty(Actor::Property::ANCHOR_POINT, "TOP_LEFT");
3739   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::TOP_LEFT, TEST_LOCATION);
3740
3741   actor.SetProperty(Actor::Property::ANCHOR_POINT, "TOP_CENTER");
3742   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::TOP_CENTER, TEST_LOCATION);
3743
3744   actor.SetProperty(Actor::Property::ANCHOR_POINT, "TOP_RIGHT");
3745   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::TOP_RIGHT, TEST_LOCATION);
3746
3747   actor.SetProperty(Actor::Property::ANCHOR_POINT, "CENTER_LEFT");
3748   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::CENTER_LEFT, TEST_LOCATION);
3749
3750   actor.SetProperty(Actor::Property::ANCHOR_POINT, "CENTER");
3751   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::CENTER, TEST_LOCATION);
3752
3753   actor.SetProperty(Actor::Property::ANCHOR_POINT, "CENTER_RIGHT");
3754   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::CENTER_RIGHT, TEST_LOCATION);
3755
3756   actor.SetProperty(Actor::Property::ANCHOR_POINT, "BOTTOM_LEFT");
3757   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::BOTTOM_LEFT, TEST_LOCATION);
3758
3759   actor.SetProperty(Actor::Property::ANCHOR_POINT, "BOTTOM_CENTER");
3760   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::BOTTOM_CENTER, TEST_LOCATION);
3761
3762   actor.SetProperty(Actor::Property::ANCHOR_POINT, "BOTTOM_RIGHT");
3763   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION);
3764
3765   // Invalid should not change anything
3766   actor.SetProperty(Actor::Property::ANCHOR_POINT, "INVALID_ARG");
3767   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION);
3768
3769   END_TEST;
3770 }
3771
3772 int UtcDaliActorParentOriginPropertyAsString(void)
3773 {
3774   TestApplication application;
3775
3776   Actor actor = Actor::New();
3777
3778   actor.SetProperty(Actor::Property::PARENT_ORIGIN, "TOP_LEFT");
3779   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::TOP_LEFT, TEST_LOCATION);
3780
3781   actor.SetProperty(Actor::Property::PARENT_ORIGIN, "TOP_CENTER");
3782   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::TOP_CENTER, TEST_LOCATION);
3783
3784   actor.SetProperty(Actor::Property::PARENT_ORIGIN, "TOP_RIGHT");
3785   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::TOP_RIGHT, TEST_LOCATION);
3786
3787   actor.SetProperty(Actor::Property::PARENT_ORIGIN, "CENTER_LEFT");
3788   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::CENTER_LEFT, TEST_LOCATION);
3789
3790   actor.SetProperty(Actor::Property::PARENT_ORIGIN, "CENTER");
3791   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::CENTER, TEST_LOCATION);
3792
3793   actor.SetProperty(Actor::Property::PARENT_ORIGIN, "CENTER_RIGHT");
3794   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::CENTER_RIGHT, TEST_LOCATION);
3795
3796   actor.SetProperty(Actor::Property::PARENT_ORIGIN, "BOTTOM_LEFT");
3797   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::BOTTOM_LEFT, TEST_LOCATION);
3798
3799   actor.SetProperty(Actor::Property::PARENT_ORIGIN, "BOTTOM_CENTER");
3800   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::BOTTOM_CENTER, TEST_LOCATION);
3801
3802   actor.SetProperty(Actor::Property::PARENT_ORIGIN, "BOTTOM_RIGHT");
3803   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION);
3804
3805   // Invalid should not change anything
3806   actor.SetProperty(Actor::Property::PARENT_ORIGIN, "INVALID_ARG");
3807   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION);
3808
3809   END_TEST;
3810 }
3811
3812 int UtcDaliActorColorModePropertyAsString(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.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), USE_OWN_COLOR, TEST_LOCATION);
3820
3821   actor.SetProperty(Actor::Property::COLOR_MODE, "USE_PARENT_COLOR");
3822   DALI_TEST_EQUALS(actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), USE_PARENT_COLOR, TEST_LOCATION);
3823
3824   actor.SetProperty(Actor::Property::COLOR_MODE, "USE_OWN_MULTIPLY_PARENT_COLOR");
3825   DALI_TEST_EQUALS(actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), 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.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION);
3829
3830   // Invalid should not change anything
3831   actor.SetProperty(Actor::Property::COLOR_MODE, "INVALID_ARG");
3832   DALI_TEST_EQUALS(actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION);
3833
3834   END_TEST;
3835 }
3836
3837 int UtcDaliActorDrawModePropertyAsString(void)
3838 {
3839   TestApplication application;
3840
3841   Actor actor = Actor::New();
3842
3843   actor.SetProperty(Actor::Property::DRAW_MODE, "NORMAL");
3844   DALI_TEST_EQUALS(actor.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE), DrawMode::NORMAL, TEST_LOCATION);
3845
3846   actor.SetProperty(Actor::Property::DRAW_MODE, "OVERLAY_2D");
3847   DALI_TEST_EQUALS(actor.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE), DrawMode::OVERLAY_2D, TEST_LOCATION);
3848
3849   // Invalid should not change anything
3850   actor.SetProperty(Actor::Property::DRAW_MODE, "INVALID_ARG");
3851   DALI_TEST_EQUALS(actor.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE), DrawMode::OVERLAY_2D, TEST_LOCATION);
3852
3853   END_TEST;
3854 }
3855
3856 int UtcDaliActorColorModePropertyAsEnum(void)
3857 {
3858   TestApplication application;
3859
3860   Actor actor = Actor::New();
3861
3862   actor.SetProperty(Actor::Property::COLOR_MODE, USE_OWN_COLOR);
3863   DALI_TEST_EQUALS(actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), USE_OWN_COLOR, TEST_LOCATION);
3864
3865   actor.SetProperty(Actor::Property::COLOR_MODE, USE_PARENT_COLOR);
3866   DALI_TEST_EQUALS(actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), USE_PARENT_COLOR, TEST_LOCATION);
3867
3868   actor.SetProperty(Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_COLOR);
3869   DALI_TEST_EQUALS(actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), USE_OWN_MULTIPLY_PARENT_COLOR, TEST_LOCATION);
3870
3871   actor.SetProperty(Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_ALPHA);
3872   DALI_TEST_EQUALS(actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION);
3873
3874   END_TEST;
3875 }
3876
3877 int UtcDaliActorDrawModePropertyAsEnum(void)
3878 {
3879   TestApplication application;
3880
3881   Actor actor = Actor::New();
3882
3883   actor.SetProperty(Actor::Property::DRAW_MODE, DrawMode::NORMAL);
3884   DALI_TEST_EQUALS(actor.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE), DrawMode::NORMAL, TEST_LOCATION);
3885
3886   actor.SetProperty(Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D);
3887   DALI_TEST_EQUALS(actor.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE), DrawMode::OVERLAY_2D, TEST_LOCATION);
3888
3889   END_TEST;
3890 }
3891
3892 int UtcDaliActorAddRendererP(void)
3893 {
3894   tet_infoline("Testing Actor::AddRenderer");
3895   TestApplication application;
3896
3897   Actor actor = Actor::New();
3898
3899   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
3900
3901   Geometry geometry = CreateQuadGeometry();
3902   Shader   shader   = CreateShader();
3903   Renderer renderer = Renderer::New(geometry, shader);
3904
3905   actor.AddRenderer(renderer);
3906   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
3907   DALI_TEST_EQUALS(actor.GetRendererAt(0), renderer, TEST_LOCATION);
3908
3909   END_TEST;
3910 }
3911
3912 int UtcDaliActorAddRendererN01(void)
3913 {
3914   tet_infoline("Testing Actor::AddRenderer");
3915   TestApplication application;
3916
3917   Actor    actor = Actor::New();
3918   Renderer renderer;
3919
3920   // try illegal Add
3921   try
3922   {
3923     actor.AddRenderer(renderer);
3924     tet_printf("Assertion test failed - no Exception\n");
3925     tet_result(TET_FAIL);
3926   }
3927   catch(Dali::DaliException& e)
3928   {
3929     DALI_TEST_PRINT_ASSERT(e);
3930     DALI_TEST_ASSERT(e, "Renderer handle is empty", TEST_LOCATION);
3931     DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
3932   }
3933   catch(...)
3934   {
3935     tet_printf("Assertion test failed - wrong Exception\n");
3936     tet_result(TET_FAIL);
3937   }
3938
3939   END_TEST;
3940 }
3941
3942 int UtcDaliActorAddRendererN02(void)
3943 {
3944   tet_infoline("UtcDaliActorAddRendererN02");
3945
3946   Actor    actor;
3947   Renderer renderer;
3948
3949   {
3950     TestApplication application;
3951
3952     Geometry geometry = CreateQuadGeometry();
3953     Shader   shader   = CreateShader();
3954     renderer          = Renderer::New(geometry, shader);
3955
3956     actor = Actor::New();
3957   }
3958
3959   // try illegal AddRenderer
3960   try
3961   {
3962     actor.AddRenderer(renderer);
3963     tet_printf("Assertion test failed - no Exception\n");
3964     tet_result(TET_FAIL);
3965   }
3966   catch(Dali::DaliException& e)
3967   {
3968     DALI_TEST_PRINT_ASSERT(e);
3969     DALI_TEST_ASSERT(e, "EventThreadServices::IsCoreRunning()", TEST_LOCATION);
3970   }
3971   catch(...)
3972   {
3973     tet_printf("Assertion test failed - wrong Exception\n");
3974     tet_result(TET_FAIL);
3975   }
3976
3977   END_TEST;
3978 }
3979
3980 int UtcDaliActorAddRendererOnScene(void)
3981 {
3982   tet_infoline("Testing Actor::AddRenderer");
3983   TestApplication application;
3984
3985   Actor actor = Actor::New();
3986   application.GetScene().Add(actor);
3987
3988   application.SendNotification();
3989   application.Render(0);
3990
3991   Geometry geometry = CreateQuadGeometry();
3992   Shader   shader   = CreateShader();
3993   Renderer renderer = Renderer::New(geometry, shader);
3994
3995   application.SendNotification();
3996   application.Render(0);
3997
3998   try
3999   {
4000     actor.AddRenderer(renderer);
4001     tet_result(TET_PASS);
4002   }
4003   catch(...)
4004   {
4005     tet_result(TET_FAIL);
4006   }
4007
4008   END_TEST;
4009 }
4010
4011 int UtcDaliActorRemoveRendererP1(void)
4012 {
4013   tet_infoline("Testing Actor::RemoveRenderer");
4014   TestApplication application;
4015
4016   Actor actor = Actor::New();
4017
4018   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
4019
4020   {
4021     Geometry geometry = CreateQuadGeometry();
4022     Shader   shader   = CreateShader();
4023     Renderer renderer = Renderer::New(geometry, shader);
4024
4025     actor.AddRenderer(renderer);
4026     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4027     DALI_TEST_EQUALS(actor.GetRendererAt(0), renderer, TEST_LOCATION);
4028
4029     application.SendNotification();
4030     application.Render();
4031   }
4032
4033   {
4034     Renderer renderer = actor.GetRendererAt(0);
4035     actor.RemoveRenderer(renderer);
4036     DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
4037
4038     application.SendNotification();
4039     application.Render();
4040   }
4041
4042   // Call one final time to ensure that the renderer is actually removed after
4043   // the handle goes out of scope, and excercises the deletion code path in
4044   // scene graph and render.
4045   application.SendNotification();
4046   application.Render();
4047
4048   END_TEST;
4049 }
4050
4051 int UtcDaliActorRemoveRendererP2(void)
4052 {
4053   tet_infoline("Testing Actor::RemoveRenderer");
4054   TestApplication application;
4055
4056   Actor actor = Actor::New();
4057
4058   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
4059
4060   Geometry geometry = CreateQuadGeometry();
4061   Shader   shader   = CreateShader();
4062   Renderer renderer = Renderer::New(geometry, shader);
4063
4064   actor.AddRenderer(renderer);
4065   application.SendNotification();
4066   application.Render();
4067
4068   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4069   DALI_TEST_EQUALS(actor.GetRendererAt(0), renderer, TEST_LOCATION);
4070
4071   actor.RemoveRenderer(0);
4072   application.SendNotification();
4073   application.Render();
4074
4075   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
4076
4077   // Shut down whilst holding onto the renderer handle.
4078   END_TEST;
4079 }
4080
4081 int UtcDaliActorRemoveRendererN(void)
4082 {
4083   tet_infoline("Testing Actor::RemoveRenderer");
4084   TestApplication application;
4085
4086   Actor actor = Actor::New();
4087
4088   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
4089
4090   Geometry geometry = CreateQuadGeometry();
4091   Shader   shader   = CreateShader();
4092   Renderer renderer = Renderer::New(geometry, shader);
4093
4094   actor.AddRenderer(renderer);
4095   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4096   DALI_TEST_EQUALS(actor.GetRendererAt(0), renderer, TEST_LOCATION);
4097
4098   actor.RemoveRenderer(10);
4099   DALI_TEST_EQUALS(actor.GetRendererAt(0), renderer, TEST_LOCATION);
4100   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4101
4102   END_TEST;
4103 }
4104
4105 // Clipping test helper functions:
4106 Actor CreateActorWithContent(uint32_t width, uint32_t height)
4107 {
4108   Texture image = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
4109   Actor   actor = CreateRenderableActor(image);
4110
4111   // Setup dimensions and position so actor is not skipped by culling.
4112   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
4113   actor.SetProperty(Actor::Property::SIZE, Vector2(width, height));
4114   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4115   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
4116
4117   return actor;
4118 }
4119
4120 Actor CreateActorWithContent16x16()
4121 {
4122   return CreateActorWithContent(16, 16);
4123 }
4124
4125 void GenerateTrace(TestApplication& application, TraceCallStack& enabledDisableTrace, TraceCallStack& stencilTrace)
4126 {
4127   enabledDisableTrace.Reset();
4128   stencilTrace.Reset();
4129   enabledDisableTrace.Enable(true);
4130   stencilTrace.Enable(true);
4131
4132   application.SendNotification();
4133   application.Render();
4134
4135   enabledDisableTrace.Enable(false);
4136   stencilTrace.Enable(false);
4137 }
4138
4139 void CheckColorMask(TestGlAbstraction& glAbstraction, bool maskValue)
4140 {
4141   const TestGlAbstraction::ColorMaskParams& colorMaskParams = glAbstraction.GetColorMaskParams();
4142
4143   DALI_TEST_EQUALS<bool>(colorMaskParams.red, maskValue, TEST_LOCATION);
4144   DALI_TEST_EQUALS<bool>(colorMaskParams.green, maskValue, TEST_LOCATION);
4145   DALI_TEST_EQUALS<bool>(colorMaskParams.blue, maskValue, TEST_LOCATION);
4146
4147   // @todo only test alpha if the framebuffer has an alpha channel
4148   //DALI_TEST_EQUALS<bool>(colorMaskParams.alpha, maskValue, TEST_LOCATION);
4149 }
4150
4151 int UtcDaliActorPropertyClippingP(void)
4152 {
4153   // This test checks the clippingMode property.
4154   tet_infoline("Testing Actor::Property::ClippingMode: P");
4155   TestApplication application;
4156
4157   Actor actor = Actor::New();
4158
4159   // Check default clippingEnabled value.
4160   Property::Value getValue(actor.GetProperty(Actor::Property::CLIPPING_MODE));
4161
4162   int  value          = 0;
4163   bool getValueResult = getValue.Get(value);
4164   DALI_TEST_CHECK(getValueResult);
4165
4166   if(getValueResult)
4167   {
4168     DALI_TEST_EQUALS<int>(value, ClippingMode::DISABLED, TEST_LOCATION);
4169   }
4170
4171   // Check setting the property to the stencil mode.
4172   actor.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
4173
4174   // Check the new value was set.
4175   getValue       = actor.GetProperty(Actor::Property::CLIPPING_MODE);
4176   getValueResult = getValue.Get(value);
4177   DALI_TEST_CHECK(getValueResult);
4178
4179   if(getValueResult)
4180   {
4181     DALI_TEST_EQUALS<int>(value, ClippingMode::CLIP_CHILDREN, TEST_LOCATION);
4182   }
4183
4184   // Check setting the property to the scissor mode.
4185   actor.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
4186
4187   // Check the new value was set.
4188   getValue       = actor.GetProperty(Actor::Property::CLIPPING_MODE);
4189   getValueResult = getValue.Get(value);
4190   DALI_TEST_CHECK(getValueResult);
4191
4192   if(getValueResult)
4193   {
4194     DALI_TEST_EQUALS<int>(value, ClippingMode::CLIP_TO_BOUNDING_BOX, TEST_LOCATION);
4195   }
4196   END_TEST;
4197 }
4198
4199 int UtcDaliActorPropertyClippingN(void)
4200 {
4201   // Negative test case for Clipping.
4202   tet_infoline("Testing Actor::Property::ClippingMode: N");
4203   TestApplication application;
4204
4205   Actor actor = Actor::New();
4206
4207   // Check default clippingEnabled value.
4208   Property::Value getValue(actor.GetProperty(Actor::Property::CLIPPING_MODE));
4209
4210   int  value          = 0;
4211   bool getValueResult = getValue.Get(value);
4212   DALI_TEST_CHECK(getValueResult);
4213
4214   if(getValueResult)
4215   {
4216     DALI_TEST_EQUALS<int>(value, ClippingMode::DISABLED, TEST_LOCATION);
4217   }
4218
4219   // Check setting an invalid property value won't change the current property value.
4220   actor.SetProperty(Actor::Property::CLIPPING_MODE, "INVALID_PROPERTY");
4221
4222   getValue       = actor.GetProperty(Actor::Property::CLIPPING_MODE);
4223   getValueResult = getValue.Get(value);
4224   DALI_TEST_CHECK(getValueResult);
4225
4226   if(getValueResult)
4227   {
4228     DALI_TEST_EQUALS<int>(value, ClippingMode::DISABLED, TEST_LOCATION);
4229   }
4230
4231   END_TEST;
4232 }
4233
4234 int UtcDaliActorPropertyClippingActor(void)
4235 {
4236   // This test checks that an actor is correctly setup for clipping.
4237   tet_infoline("Testing Actor::Property::ClippingMode: CLIP_CHILDREN actor");
4238   TestApplication application;
4239
4240   // @todo temporary until stencil code has been fixed.
4241 #ifdef TEMPORARY_TEST_REMOVAL
4242
4243   TestGlAbstraction& glAbstraction       = application.GetGlAbstraction();
4244   TraceCallStack&    stencilTrace        = glAbstraction.GetStencilFunctionTrace();
4245   TraceCallStack&    enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4246   size_t             startIndex          = 0u;
4247
4248   // Create a clipping actor.
4249   Actor actorDepth1Clip = CreateActorWithContent16x16();
4250   actorDepth1Clip.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
4251   application.GetScene().Add(actorDepth1Clip);
4252
4253   // Gather the call trace.
4254   GenerateTrace(application, enabledDisableTrace, stencilTrace);
4255
4256   // Check we are writing to the color buffer.
4257   CheckColorMask(glAbstraction, true);
4258
4259   // Check the stencil buffer was enabled.
4260   std::ostringstream oss;
4261   oss << std::hex << GL_STENCIL_TEST;
4262   DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", oss.str()));
4263
4264   // Check the stencil buffer was cleared.
4265   DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("ClearStencil", "0", startIndex));
4266
4267   // Check the correct setup was done to write to the first bit-plane (only) of the stencil buffer.
4268   DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilFunc", "514, 1, 0", startIndex)); // 514 is GL_EQUAL, But testing no bit-planes for the first clipping node.
4269   DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilMask", "1", startIndex));
4270   DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilOp", "7680, 7681, 7681", startIndex)); // GL_KEEP, GL_REPLACE, GL_REPLACE
4271 #else
4272   DALI_TEST_CHECK(true);
4273 #endif
4274
4275   END_TEST;
4276 }
4277
4278 int UtcDaliActorPropertyClippingActorEnableThenDisable(void)
4279 {
4280   // This test checks that an actor is correctly setup for clipping and then correctly setup when clipping is disabled
4281   tet_infoline("Testing Actor::Property::ClippingMode: CLIP_CHILDREN actor enable and then disable");
4282   TestApplication application;
4283
4284   // @todo temporary until stencil code has been fixed.
4285 #ifdef TEMPORARY_TEST_REMOVAL
4286
4287   TestGlAbstraction& glAbstraction       = application.GetGlAbstraction();
4288   TraceCallStack&    stencilTrace        = glAbstraction.GetStencilFunctionTrace();
4289   TraceCallStack&    enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4290   size_t             startIndex          = 0u;
4291
4292   // Create a clipping actor.
4293   Actor actorDepth1Clip = CreateActorWithContent16x16();
4294   actorDepth1Clip.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
4295   application.GetScene().Add(actorDepth1Clip);
4296
4297   // Gather the call trace.
4298   GenerateTrace(application, enabledDisableTrace, stencilTrace);
4299
4300   // Check we are writing to the color buffer.
4301   CheckColorMask(glAbstraction, true);
4302
4303   // Check the stencil buffer was enabled.
4304   std::ostringstream oss;
4305   oss << std::hex << GL_STENCIL_TEST;
4306   DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", oss.str()));
4307
4308   // Check the stencil buffer was cleared.
4309   DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("ClearStencil", "0", startIndex));
4310
4311   // Check the correct setup was done to write to the first bit-plane (only) of the stencil buffer.
4312   DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilFunc", "514, 1, 0", startIndex)); // 514 is GL_EQUAL, But testing no bit-planes for the first clipping node.
4313   DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilMask", "1", startIndex));
4314   DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilOp", "7680, 7681, 7681", startIndex)); // GL_KEEP, GL_REPLACE, GL_REPLACE
4315
4316   // Now disable the clipping
4317   actorDepth1Clip.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::DISABLED);
4318
4319   // Gather the call trace.
4320   GenerateTrace(application, enabledDisableTrace, stencilTrace);
4321
4322   // Check the stencil buffer was disabled.
4323   std::ostringstream stencil;
4324   stencil << std::hex << GL_STENCIL_TEST;
4325   DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Disable", stencil.str()));
4326
4327   // Ensure all values in stencil-mask are set to 1.
4328   startIndex = 0u;
4329   DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilMask", "255", startIndex));
4330
4331 #else
4332   DALI_TEST_CHECK(true);
4333 #endif
4334
4335   END_TEST;
4336 }
4337
4338 int UtcDaliActorPropertyClippingNestedChildren(void)
4339 {
4340   // This test checks that a hierarchy of actors are clipped correctly by
4341   // writing to and reading from the correct bit-planes of the stencil buffer.
4342   tet_infoline("Testing Actor::Property::ClippingMode: CLIP_CHILDREN nested children");
4343
4344   // @todo temporary until stencil code has been fixed.
4345 #ifdef TEMPORARY_TEST_REMOVAL
4346   TestApplication    application;
4347   TestGlAbstraction& glAbstraction       = application.GetGlAbstraction();
4348   TraceCallStack&    stencilTrace        = glAbstraction.GetStencilFunctionTrace();
4349   TraceCallStack&    enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4350
4351   // Create a clipping actor.
4352   Actor actorDepth1Clip = CreateActorWithContent16x16();
4353   actorDepth1Clip.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
4354   application.GetScene().Add(actorDepth1Clip);
4355
4356   // Create a child actor.
4357   Actor childDepth2 = CreateActorWithContent16x16();
4358   actorDepth1Clip.Add(childDepth2);
4359
4360   // Create another clipping actor.
4361   Actor childDepth2Clip = CreateActorWithContent16x16();
4362   childDepth2Clip.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
4363   childDepth2.Add(childDepth2Clip);
4364
4365   // Create another 2 child actors. We do this so 2 nodes will have the same clipping ID.
4366   // This tests the sort algorithm.
4367   Actor childDepth3 = CreateActorWithContent16x16();
4368   childDepth2Clip.Add(childDepth3);
4369   Actor childDepth4 = CreateActorWithContent16x16();
4370   childDepth3.Add(childDepth4);
4371
4372   // Gather the call trace.
4373   GenerateTrace(application, enabledDisableTrace, stencilTrace);
4374
4375   // Check we are writing to the color buffer.
4376   CheckColorMask(glAbstraction, true);
4377
4378   // Check the stencil buffer was enabled.
4379   std::ostringstream oss;
4380   oss << std::hex << GL_STENCIL_TEST;
4381   DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", oss.str()));
4382
4383   // Perform the test twice, once for 2D layer, and once for 3D.
4384   for(unsigned int i = 0u; i < 2u; ++i)
4385   {
4386     size_t startIndex = 0u;
4387
4388     // Check the stencil buffer was cleared.
4389     DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("ClearStencil", "0", startIndex));
4390
4391     // Check the correct setup was done to write to the first bit-plane (only) of the stencil buffer.
4392     DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilFunc", "514, 1, 0", startIndex));      // 514 is GL_EQUAL, But testing no bit-planes for the first clipping node.
4393     DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilMask", "1", startIndex));              // Write to the first bit-plane
4394     DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilOp", "7680, 7681, 7681", startIndex)); // GL_KEEP, GL_REPLACE, GL_REPLACE
4395
4396     // Check the correct setup was done to test against first bit-plane (only) of the stencil buffer.
4397     DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilFunc", "514, 1, 1", startIndex));      // 514 is GL_EQUAL
4398     DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilOp", "7680, 7680, 7680", startIndex)); // GL_KEEP, GL_KEEP, GL_KEEP
4399
4400     // Check we are set up to write to the second bitplane of the stencil buffer (only).
4401     DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilFunc", "514, 3, 1", startIndex));      // 514 is GL_EQUAL, Test both bit-planes 1 & 2
4402     DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilMask", "3", startIndex));              // Write to second (and previous) bit-planes
4403     DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilOp", "7680, 7681, 7681", startIndex)); // GL_KEEP, GL_REPLACE, GL_REPLACE
4404
4405     // Check we are set up to test against both the first and second bit-planes of the stencil buffer.
4406     // (Both must be set to pass the check).
4407     DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilFunc", "514, 3, 3", startIndex));      // 514 is GL_EQUAL, Test both bit-planes 1 & 2
4408     DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilOp", "7680, 7680, 7680", startIndex)); // GL_KEEP, GL_KEEP, GL_KEEP
4409
4410     // If we are on the first loop, set the layer to 3D and loop to perform the test again.
4411     if(i == 0u)
4412     {
4413       application.GetScene().GetRootLayer().SetProperty(Layer::Property::BEHAVIOR, Layer::LAYER_3D);
4414       GenerateTrace(application, enabledDisableTrace, stencilTrace);
4415     }
4416   }
4417 #else
4418   DALI_TEST_CHECK(true);
4419 #endif
4420
4421   END_TEST;
4422 }
4423
4424 int UtcDaliActorPropertyClippingActorDrawOrder(void)
4425 {
4426   // This test checks that a hierarchy of actors are drawn in the correct order when clipping is enabled.
4427   tet_infoline("Testing Actor::Property::ClippingMode: CLIP_CHILDREN draw order");
4428
4429   // @todo temporary until stencil code has been fixed.
4430 #ifdef TEMPORARY_TEST_REMOVAL
4431   TestApplication    application;
4432   TestGlAbstraction& glAbstraction       = application.GetGlAbstraction();
4433   TraceCallStack&    enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4434
4435   /* We create a small tree of actors as follows:
4436
4437                            A
4438                           / \
4439      Clipping enabled -> B   D
4440                          |   |
4441                          C   E
4442
4443      The correct draw order is "ABCDE" (the same as if clipping was not enabled).
4444   */
4445   Actor actors[5];
4446   for(int i = 0; i < 5; ++i)
4447   {
4448     Texture image = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, 16u, 16u);
4449     Actor   actor = CreateRenderableActor(image);
4450
4451     // Setup dimensions and position so actor is not skipped by culling.
4452     actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
4453     actor.SetProperty(Actor::Property::SIZE, Vector2(16.0f, 16.0f));
4454
4455     if(i == 0)
4456     {
4457       actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4458     }
4459     else
4460     {
4461       float b = i > 2 ? 1.0f : -1.0f;
4462       actor.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.5 + (0.2f * b), 0.8f, 0.8f));
4463     }
4464
4465     actors[i] = actor;
4466   }
4467
4468   // Enable clipping on the actor at the top of the left branch.
4469   actors[1].SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
4470
4471   // Build the scene graph.
4472   application.GetScene().Add(actors[0]);
4473
4474   // Left branch:
4475   actors[0].Add(actors[1]);
4476   actors[1].Add(actors[2]);
4477
4478   // Right branch:
4479   actors[0].Add(actors[3]);
4480   actors[3].Add(actors[4]);
4481
4482   // Gather the call trace.
4483   enabledDisableTrace.Reset();
4484   enabledDisableTrace.Enable(true);
4485   application.SendNotification();
4486   application.Render();
4487   enabledDisableTrace.Enable(false);
4488
4489   /* Check stencil is enabled and disabled again (as right-hand branch of tree is drawn).
4490
4491      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
4492            Incorrect enable call trace:  StackTrace: Index:0, Function:Enable, ParamList:3042 StackTrace: Index:1, Function:Enable, ParamList:2960
4493   */
4494   size_t             startIndex = 0u;
4495   std::ostringstream blend;
4496   blend << std::hex << GL_BLEND;
4497   std::ostringstream stencil;
4498   stencil << std::hex << GL_STENCIL_TEST;
4499
4500   DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParamsFromStartIndex("Enable", blend.str(), startIndex));
4501   DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParamsFromStartIndex("Enable", stencil.str(), startIndex));
4502   DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParamsFromStartIndex("Disable", stencil.str(), startIndex));
4503
4504   // Swap the clipping actor from top of left branch to top of right branch.
4505   actors[1].SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::DISABLED);
4506   actors[3].SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
4507
4508   // Gather the call trace.
4509   enabledDisableTrace.Reset();
4510   enabledDisableTrace.Enable(true);
4511   application.SendNotification();
4512   application.Render();
4513   enabledDisableTrace.Enable(false);
4514
4515   // Check stencil is enabled but NOT disabled again (as right-hand branch of tree is drawn).
4516   // This proves the draw order has remained the same.
4517   startIndex = 0u;
4518   DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParamsFromStartIndex("Enable", stencil.str(), startIndex));
4519   DALI_TEST_CHECK(!enabledDisableTrace.FindMethodAndParamsFromStartIndex("Disable", stencil.str(), startIndex));
4520
4521 #else
4522   DALI_TEST_CHECK(true);
4523 #endif
4524
4525   END_TEST;
4526 }
4527
4528 int UtcDaliActorPropertyScissorClippingActor(void)
4529 {
4530   // This test checks that an actor is correctly setup for clipping.
4531   tet_infoline("Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor");
4532   TestApplication application;
4533
4534   TestGlAbstraction& glAbstraction       = application.GetGlAbstraction();
4535   TraceCallStack&    scissorTrace        = glAbstraction.GetScissorTrace();
4536   TraceCallStack&    enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4537
4538   const Vector2 stageSize(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT);
4539   const Vector2 imageSize(16.0f, 16.0f);
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.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_LEFT);
4546   clippingActorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_LEFT);
4547   clippingActorA.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
4548   application.GetScene().Add(clippingActorA);
4549
4550   // Gather the call trace.
4551   GenerateTrace(application, enabledDisableTrace, scissorTrace);
4552
4553   // Check we are writing to the color buffer.
4554   CheckColorMask(glAbstraction, true);
4555
4556   // Check scissor test was enabled.
4557
4558   std::ostringstream scissor;
4559   scissor << std::hex << GL_SCISSOR_TEST;
4560   DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", scissor.str()));
4561
4562   // Check the scissor was set, and the coordinates are correct.
4563   std::stringstream compareParametersString;
4564   compareParametersString << "0, 0, " << imageSize.x << ", " << imageSize.y;
4565   DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", compareParametersString.str())); // Compare with 0, 0, 16, 16
4566
4567   clippingActorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_RIGHT);
4568   clippingActorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_RIGHT);
4569
4570   // Gather the call trace.
4571   GenerateTrace(application, enabledDisableTrace, scissorTrace);
4572
4573   // Check the scissor was set, and the coordinates are correct.
4574   compareParametersString.str(std::string());
4575   compareParametersString.clear();
4576   compareParametersString << (stageSize.x - imageSize.x) << ", " << (stageSize.y - imageSize.y) << ", " << imageSize.x << ", " << imageSize.y;
4577   DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", compareParametersString.str())); // Compare with 464, 784, 16, 16
4578
4579   END_TEST;
4580 }
4581
4582 int UtcDaliActorPropertyScissorClippingActorSiblings(void)
4583 {
4584   // This test checks that an actor is correctly setup for clipping.
4585   tet_infoline("Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actors which are siblings");
4586   TestApplication application;
4587
4588   TestGlAbstraction& glAbstraction       = application.GetGlAbstraction();
4589   TraceCallStack&    scissorTrace        = glAbstraction.GetScissorTrace();
4590   TraceCallStack&    enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4591
4592   const Vector2 stageSize(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT);
4593   const Vector2 sizeA{stageSize.width, stageSize.height * 0.25f};
4594   const Vector2 sizeB{stageSize.width, stageSize.height * 0.05f};
4595
4596   // Create a clipping actors.
4597   Actor clippingActorA = CreateActorWithContent(sizeA.width, sizeA.height);
4598   Actor clippingActorB = CreateActorWithContent(sizeB.width, sizeB.height);
4599
4600   clippingActorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT);
4601   clippingActorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
4602   clippingActorA.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
4603
4604   clippingActorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT);
4605   clippingActorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
4606   clippingActorB.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
4607
4608   clippingActorA.SetProperty(Actor::Property::POSITION, Vector3(0.0f, -200.0f, 0.0f));
4609   clippingActorB.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
4610
4611   application.GetScene().Add(clippingActorA);
4612   application.GetScene().Add(clippingActorB);
4613
4614   // Gather the call trace.
4615   GenerateTrace(application, enabledDisableTrace, scissorTrace);
4616
4617   // Check we are writing to the color buffer.
4618   CheckColorMask(glAbstraction, true);
4619
4620   // Check scissor test was enabled.
4621   std::ostringstream scissor;
4622   scissor << std::hex << GL_SCISSOR_TEST;
4623   DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", scissor.str()));
4624
4625   // Check the scissor was set, and the coordinates are correct.
4626   std::stringstream compareParametersString;
4627
4628   std::string clipA("0, 500, 480, 200");
4629   std::string clipB("0, 380, 480, 40");
4630
4631   DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", clipA));
4632   DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", clipB));
4633
4634   END_TEST;
4635 }
4636
4637 int UtcDaliActorPropertyScissorClippingActorNested01(void)
4638 {
4639   // This test checks that an actor is correctly setup for clipping.
4640   tet_infoline("Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor nested");
4641   TestApplication application;
4642
4643   TestGlAbstraction& glAbstraction       = application.GetGlAbstraction();
4644   TraceCallStack&    scissorTrace        = glAbstraction.GetScissorTrace();
4645   TraceCallStack&    enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4646
4647   const Vector2 stageSize(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT);
4648   const Vector2 imageSize(16.0f, 16.0f);
4649
4650   /* Create a nest of 2 scissors to test nesting (intersecting clips).
4651
4652      A is drawn first - with scissor clipping on
4653      B is drawn second - also with scissor clipping on
4654      C is the generated clipping region, the intersection ( A ∩ B )
4655
4656            ┏━━━━━━━┓                   ┌───────┐
4657            ┃     B ┃                   │     B │
4658        ┌───╂┄┄┄┐   ┃               ┌┄┄┄╆━━━┓   │
4659        │   ┃   ┊   ┃     ━━━━━>    ┊   ┃ C ┃   │
4660        │   ┗━━━┿━━━┛               ┊   ┗━━━╃───┘
4661        │ A     │                   ┊ A     ┊
4662        └───────┘                   └┄┄┄┄┄┄┄┘
4663
4664      We then reposition B around each corner of A to test the 4 overlap combinations (thus testing intersecting works correctly).
4665   */
4666
4667   // Create a clipping actor.
4668   Actor clippingActorA = CreateActorWithContent16x16();
4669   // Note: Scissor coords are have flipped Y values compared with DALi's coordinate system.
4670   // We choose BOTTOM_LEFT to give us x=0, y=0 starting coordinates for the first test.
4671   clippingActorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4672   clippingActorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
4673   clippingActorA.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
4674   application.GetScene().Add(clippingActorA);
4675
4676   // Create a child clipping actor.
4677   Actor clippingActorB = CreateActorWithContent16x16();
4678   clippingActorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4679   clippingActorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
4680   clippingActorB.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
4681   clippingActorA.Add(clippingActorB);
4682
4683   // positionModifiers is an array of positions to position B around.
4684   // expect is an array of expected scissor clip coordinate results.
4685   const Vector2 positionModifiers[4] = {Vector2(1.0f, 1.0f), Vector2(-1.0f, 1.0f), Vector2(-1.0f, -1.0f), Vector2(1.0f, -1.0f)};
4686   const Vector4 expect[4]            = {Vector4(240, 392, 8, 8), Vector4(232, 392, 8, 8), Vector4(232, 400, 8, 8), Vector4(240, 400, 8, 8)};
4687
4688   // Loop through each overlap combination.
4689   for(unsigned int test = 0u; test < 4u; ++test)
4690   {
4691     // Position the child clipping actor so it intersects with the 1st clipping actor. This changes each loop.
4692     const Vector2 position = (imageSize / 2.0f) * positionModifiers[test];
4693     clippingActorB.SetProperty(Actor::Property::POSITION, Vector2(position.x, position.y));
4694
4695     // Gather the call trace.
4696     GenerateTrace(application, enabledDisableTrace, scissorTrace);
4697
4698     // Check we are writing to the color buffer.
4699     CheckColorMask(glAbstraction, true);
4700
4701     // Check scissor test was enabled.
4702     std::ostringstream scissor;
4703     scissor << std::hex << GL_SCISSOR_TEST;
4704     DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", scissor.str()));
4705
4706     // Check the scissor was set, and the coordinates are correct.
4707     const Vector4&    expectResults(expect[test]);
4708     std::stringstream compareParametersString;
4709     compareParametersString << expectResults.x << ", " << expectResults.y << ", " << expectResults.z << ", " << expectResults.w;
4710     DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", compareParametersString.str())); // Compare with the expected result
4711   }
4712
4713   END_TEST;
4714 }
4715
4716 int UtcDaliActorPropertyScissorClippingActorNested02(void)
4717 {
4718   // This test checks that an actor is correctly setup for clipping.
4719   tet_infoline("Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor nested");
4720   TestApplication application;
4721
4722   TestGlAbstraction& glAbstraction       = application.GetGlAbstraction();
4723   TraceCallStack&    scissorTrace        = glAbstraction.GetScissorTrace();
4724   TraceCallStack&    enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4725
4726   /* Create a nest of 2 scissors and siblings of the parent.
4727
4728             stage
4729               |
4730         ┌─────┐─────┐
4731         A     C     D
4732         |           |
4733         B           E
4734   */
4735
4736   const Vector2 stageSize(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT);
4737   const Vector2 sizeA{stageSize.width, stageSize.height * 0.25f};
4738   const Vector2 sizeB{stageSize.width, stageSize.height * 0.05f};
4739   const Vector2 sizeC{stageSize.width, stageSize.height * 0.25f};
4740   const Vector2 sizeD{stageSize.width, stageSize.height * 0.25f};
4741   const Vector2 sizeE{stageSize.width, stageSize.height * 0.05f};
4742
4743   // Create a clipping actors.
4744   Actor clippingActorA = CreateActorWithContent(sizeA.width, sizeA.height);
4745   Actor clippingActorB = CreateActorWithContent(sizeB.width, sizeB.height);
4746   Actor clippingActorC = CreateActorWithContent(sizeC.width, sizeC.height);
4747   Actor clippingActorD = CreateActorWithContent(sizeD.width, sizeD.height);
4748   Actor clippingActorE = CreateActorWithContent(sizeE.width, sizeE.height);
4749
4750   clippingActorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT);
4751   clippingActorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
4752   clippingActorA.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
4753
4754   clippingActorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT);
4755   clippingActorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
4756   clippingActorB.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
4757
4758   clippingActorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT);
4759   clippingActorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
4760   clippingActorC.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
4761
4762   clippingActorD.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT);
4763   clippingActorD.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
4764   clippingActorD.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
4765
4766   clippingActorE.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT);
4767   clippingActorE.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
4768
4769   clippingActorA.SetProperty(Actor::Property::POSITION, Vector3(0.0f, -200.0f, 0.0f));
4770   clippingActorB.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
4771   clippingActorC.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 100.0f, 0.0f));
4772   clippingActorD.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
4773   clippingActorE.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
4774
4775   application.GetScene().Add(clippingActorA);
4776   clippingActorA.Add(clippingActorB);
4777   application.GetScene().Add(clippingActorC);
4778   application.GetScene().Add(clippingActorD);
4779   clippingActorD.Add(clippingActorE);
4780
4781   // Gather the call trace.
4782   GenerateTrace(application, enabledDisableTrace, scissorTrace);
4783
4784   // Check we are writing to the color buffer.
4785   CheckColorMask(glAbstraction, true);
4786
4787   // Check scissor test was enabled.
4788   std::ostringstream scissor;
4789   scissor << std::hex << GL_SCISSOR_TEST;
4790   DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", scissor.str()));
4791
4792   // Check the scissor was set, and the coordinates are correct.
4793   std::string clipA("0, 500, 480, 200");
4794   std::string clipB("0, 580, 480, 40");
4795   std::string clipC("0, 200, 480, 200");
4796   std::string clipD("0, 300, 480, 200");
4797
4798   DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", clipA));
4799   DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", clipB));
4800   DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", clipC));
4801   DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", clipD));
4802   DALI_TEST_EQUALS(scissorTrace.CountMethod("Scissor"), 4, TEST_LOCATION); // Scissor rect should not be changed in clippingActorE case. So count should be 4.
4803
4804   END_TEST;
4805 }
4806
4807 int UtcDaliActorPropertyClippingActorWithRendererOverride(void)
4808 {
4809   // This test checks that an actor with clipping will be ignored if overridden by the Renderer properties.
4810   tet_infoline("Testing Actor::Property::CLIPPING_MODE actor with renderer override");
4811   TestApplication application;
4812
4813   TestGlAbstraction& glAbstraction       = application.GetGlAbstraction();
4814   TraceCallStack&    stencilTrace        = glAbstraction.GetStencilFunctionTrace();
4815   TraceCallStack&    enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4816
4817   // Create a clipping actor.
4818   Actor actorDepth1Clip = CreateActorWithContent16x16();
4819   actorDepth1Clip.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
4820   application.GetScene().Add(actorDepth1Clip);
4821
4822   // Turn the RenderMode to just "COLOR" at the Renderer level to ignore the clippingMode.
4823   actorDepth1Clip.GetRendererAt(0).SetProperty(Renderer::Property::RENDER_MODE, RenderMode::COLOR);
4824
4825   // Gather the call trace.
4826   GenerateTrace(application, enabledDisableTrace, stencilTrace);
4827
4828   // Check we are writing to the color buffer.
4829   CheckColorMask(glAbstraction, true);
4830
4831   // Check the stencil buffer was not enabled.
4832   std::ostringstream stencil;
4833   stencil << std::hex << GL_STENCIL_TEST;
4834   DALI_TEST_CHECK(!enabledDisableTrace.FindMethodAndParams("Enable", stencil.str()));
4835
4836   // Check stencil functions are not called.
4837   DALI_TEST_CHECK(!stencilTrace.FindMethod("StencilFunc"));
4838   // TODO: Temporarily commented out the line below when caching is disabled. Will need to add it back.
4839   //  DALI_TEST_CHECK(!stencilTrace.FindMethod("StencilMask"));
4840   DALI_TEST_CHECK(!stencilTrace.FindMethod("StencilOp"));
4841
4842   // Check that scissor clipping is overriden by the renderer properties.
4843   TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
4844
4845   actorDepth1Clip.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
4846
4847   // Gather the call trace.
4848   GenerateTrace(application, enabledDisableTrace, scissorTrace);
4849
4850   // Check the stencil buffer was not enabled.
4851   std::ostringstream scissor;
4852   scissor << std::hex << GL_SCISSOR_TEST;
4853   DALI_TEST_CHECK(!enabledDisableTrace.FindMethodAndParams("Enable", scissor.str()));
4854
4855   DALI_TEST_CHECK(!scissorTrace.FindMethod("StencilFunc"));
4856
4857   END_TEST;
4858 }
4859
4860 int UtcDaliGetPropertyN(void)
4861 {
4862   tet_infoline("Testing Actor::GetProperty returns a non valid value if property index is out of range");
4863   TestApplication application;
4864
4865   Actor actor = Actor::New();
4866
4867   unsigned int propertyCount = actor.GetPropertyCount();
4868   DALI_TEST_EQUALS(actor.GetProperty(Property::Index(propertyCount)).GetType(), Property::NONE, TEST_LOCATION);
4869   END_TEST;
4870 }
4871
4872 int UtcDaliActorRaiseLower(void)
4873 {
4874   tet_infoline("UtcDaliActor Raise and Lower test\n");
4875
4876   TestApplication application;
4877
4878   Debug::Filter::SetGlobalLogLevel(Debug::Verbose);
4879
4880   Integration::Scene stage(application.GetScene());
4881
4882   Actor actorA = Actor::New();
4883   Actor actorB = Actor::New();
4884   Actor actorC = Actor::New();
4885
4886   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
4887   actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4888
4889   actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
4890   actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4891
4892   actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
4893   actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4894
4895   actorA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
4896   actorA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
4897
4898   actorB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
4899   actorB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
4900
4901   actorC.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
4902   actorC.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
4903
4904   stage.Add(actorA);
4905   stage.Add(actorB);
4906   stage.Add(actorC);
4907
4908   ResetTouchCallbacks();
4909
4910   application.SendNotification();
4911   application.Render();
4912
4913   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
4914   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
4915   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
4916
4917   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
4918   // Only top actor will get touched.
4919   actorA.TouchedSignal().Connect(TestTouchCallback);
4920   actorB.TouchedSignal().Connect(TestTouchCallback2);
4921   actorC.TouchedSignal().Connect(TestTouchCallback3);
4922
4923   // Connect ChildOrderChangedSignal
4924   bool                     orderChangedSignal(false);
4925   Actor                    orderChangedActor;
4926   ChildOrderChangedFunctor f(orderChangedSignal, orderChangedActor);
4927   DevelActor::ChildOrderChangedSignal(stage.GetRootLayer()).Connect(&application, f);
4928
4929   Dali::Integration::Point point;
4930   point.SetDeviceId(1);
4931   point.SetState(PointState::DOWN);
4932   point.SetScreenPosition(Vector2(10.f, 10.f));
4933   Dali::Integration::TouchEvent touchEvent;
4934   touchEvent.AddPoint(point);
4935
4936   application.ProcessEvent(touchEvent);
4937
4938   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
4939   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
4940   DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
4941
4942   ResetTouchCallbacks();
4943
4944   tet_printf("Testing Raising of Actor\n");
4945
4946   int preActorOrder(0);
4947   int postActorOrder(0);
4948
4949   Property::Value value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER);
4950   value.Get(preActorOrder);
4951
4952   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
4953   actorB.Raise();
4954   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
4955   DALI_TEST_EQUALS(orderChangedActor, actorB, TEST_LOCATION);
4956
4957   // Ensure sort order is calculated before next touch event
4958   application.SendNotification();
4959
4960   value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER);
4961   value.Get(postActorOrder);
4962
4963   tet_printf("Raised ActorB from (%d) to (%d) \n", preActorOrder, postActorOrder);
4964
4965   application.ProcessEvent(touchEvent);
4966
4967   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
4968   DALI_TEST_EQUALS(gTouchCallBackCalled2, true, TEST_LOCATION);
4969   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
4970
4971   ResetTouchCallbacks();
4972
4973   tet_printf("Testing Lowering of Actor\n");
4974
4975   value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER);
4976   value.Get(preActorOrder);
4977
4978   orderChangedSignal = false;
4979
4980   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
4981   actorB.Lower();
4982   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
4983   DALI_TEST_EQUALS(orderChangedActor, actorB, TEST_LOCATION);
4984
4985   application.SendNotification(); // ensure sort order calculated before next touch event
4986
4987   value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER);
4988   value.Get(postActorOrder);
4989
4990   tet_printf("Lowered ActorB from (%d) to (%d) \n", preActorOrder, postActorOrder);
4991
4992   application.ProcessEvent(touchEvent);
4993
4994   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
4995   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
4996   DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
4997
4998   ResetTouchCallbacks();
4999
5000   Debug::Filter::SetGlobalLogLevel(Debug::NoLogging);
5001
5002   END_TEST;
5003 }
5004
5005 int UtcDaliActorRaiseToTopLowerToBottom(void)
5006 {
5007   tet_infoline("UtcDaliActorRaiseToTop and LowerToBottom test \n");
5008
5009   TestApplication application;
5010
5011   Integration::Scene stage(application.GetScene());
5012
5013   Actor actorA = Actor::New();
5014   Actor actorB = Actor::New();
5015   Actor actorC = Actor::New();
5016
5017   // Set up renderers to add to Actors, float value 1, 2, 3 assigned to each
5018   // enables checking of which actor the uniform is assigned too
5019   Shader shaderA = CreateShader();
5020   shaderA.RegisterProperty("uRendererColor", 1.f);
5021
5022   Shader shaderB = CreateShader();
5023   shaderB.RegisterProperty("uRendererColor", 2.f);
5024
5025   Shader shaderC = CreateShader();
5026   shaderC.RegisterProperty("uRendererColor", 3.f);
5027
5028   Geometry geometry = CreateQuadGeometry();
5029
5030   // Add renderers to Actors so ( uRendererColor, 1 ) is A, ( uRendererColor, 2 ) is B, and ( uRendererColor, 3 ) is C,
5031   Renderer rendererA = Renderer::New(geometry, shaderA);
5032   actorA.AddRenderer(rendererA);
5033
5034   Renderer rendererB = Renderer::New(geometry, shaderB);
5035   actorB.AddRenderer(rendererB);
5036
5037   Renderer rendererC = Renderer::New(geometry, shaderC);
5038   actorC.AddRenderer(rendererC);
5039
5040   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5041   actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5042
5043   actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5044   actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5045
5046   actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5047   actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5048
5049   actorA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5050   actorA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5051
5052   actorB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5053   actorB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5054
5055   actorC.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5056   actorC.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5057
5058   stage.Add(actorA);
5059   stage.Add(actorB);
5060   stage.Add(actorC);
5061
5062   ResetTouchCallbacks();
5063
5064   // Connect ChildOrderChangedSignal
5065   bool                     orderChangedSignal(false);
5066   Actor                    orderChangedActor;
5067   ChildOrderChangedFunctor f(orderChangedSignal, orderChangedActor);
5068   DevelActor::ChildOrderChangedSignal(stage.GetRootLayer()).Connect(&application, f);
5069
5070   // Set up gl abstraction trace so can query the set uniform order
5071   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
5072   glAbstraction.EnableSetUniformCallTrace(true);
5073   glAbstraction.ResetSetUniformCallStack();
5074
5075   TraceCallStack& glSetUniformStack = glAbstraction.GetSetUniformTrace();
5076
5077   application.SendNotification();
5078   application.Render();
5079
5080   tet_printf("Trace Output:%s \n", glSetUniformStack.GetTraceString().c_str());
5081
5082   // Test order of uniforms in stack
5083   int indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3.000000");
5084   int indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2.000000");
5085   int indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1.000000");
5086
5087   bool CBA = (indexC > indexB) && (indexB > indexA);
5088
5089   DALI_TEST_EQUALS(CBA, true, TEST_LOCATION);
5090
5091   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5092   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
5093   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
5094
5095   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
5096   // Only top actor will get touched.
5097   actorA.TouchedSignal().Connect(TestTouchCallback);
5098   actorB.TouchedSignal().Connect(TestTouchCallback2);
5099   actorC.TouchedSignal().Connect(TestTouchCallback3);
5100
5101   Dali::Integration::Point point;
5102   point.SetDeviceId(1);
5103   point.SetState(PointState::DOWN);
5104   point.SetScreenPosition(Vector2(10.f, 10.f));
5105   Dali::Integration::TouchEvent touchEvent;
5106   touchEvent.AddPoint(point);
5107
5108   application.ProcessEvent(touchEvent);
5109
5110   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5111   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
5112   DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
5113
5114   ResetTouchCallbacks();
5115
5116   tet_printf("RaiseToTop ActorA\n");
5117
5118   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
5119   actorA.RaiseToTop();
5120   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
5121   DALI_TEST_EQUALS(orderChangedActor, actorA, TEST_LOCATION);
5122
5123   application.SendNotification(); // ensure sorting order is calculated before next touch event
5124
5125   application.ProcessEvent(touchEvent);
5126
5127   glSetUniformStack.Reset();
5128
5129   application.SendNotification();
5130   application.Render();
5131
5132   tet_printf("Trace:%s \n", glSetUniformStack.GetTraceString().c_str());
5133
5134   // Test order of uniforms in stack
5135   indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3.000000");
5136   indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2.000000");
5137   indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1.000000");
5138
5139   tet_infoline("Testing A above C and B at bottom\n");
5140   bool ACB = (indexA > indexC) && (indexC > indexB);
5141
5142   DALI_TEST_EQUALS(ACB, true, TEST_LOCATION);
5143
5144   DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
5145   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
5146   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
5147
5148   ResetTouchCallbacks();
5149
5150   tet_printf("RaiseToTop ActorB\n");
5151
5152   orderChangedSignal = false;
5153
5154   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
5155   actorB.RaiseToTop();
5156   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
5157   DALI_TEST_EQUALS(orderChangedActor, actorB, TEST_LOCATION);
5158
5159   application.SendNotification(); // Ensure sort order is calculated before next touch event
5160
5161   application.ProcessEvent(touchEvent);
5162
5163   glSetUniformStack.Reset();
5164
5165   application.SendNotification();
5166   application.Render();
5167
5168   tet_printf("Trace:%s \n", glSetUniformStack.GetTraceString().c_str());
5169
5170   // Test order of uniforms in stack
5171   indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3.000000");
5172   indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2.000000");
5173   indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1.000000");
5174
5175   tet_infoline("Testing B above A and C at bottom\n");
5176   bool BAC = (indexB > indexA) && (indexA > indexC);
5177
5178   DALI_TEST_EQUALS(BAC, true, TEST_LOCATION);
5179
5180   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5181   DALI_TEST_EQUALS(gTouchCallBackCalled2, true, TEST_LOCATION);
5182   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
5183
5184   ResetTouchCallbacks();
5185
5186   tet_printf("LowerToBottom ActorA then ActorB leaving Actor C at Top\n");
5187
5188   orderChangedSignal = false;
5189
5190   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
5191   actorA.LowerToBottom();
5192   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
5193   DALI_TEST_EQUALS(orderChangedActor, actorA, TEST_LOCATION);
5194
5195   application.SendNotification();
5196   application.Render();
5197
5198   orderChangedSignal = false;
5199
5200   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
5201   actorB.LowerToBottom();
5202   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
5203   DALI_TEST_EQUALS(orderChangedActor, actorB, TEST_LOCATION);
5204
5205   application.SendNotification();
5206   application.Render();
5207
5208   application.ProcessEvent(touchEvent);
5209
5210   glSetUniformStack.Reset();
5211
5212   application.SendNotification();
5213   application.Render();
5214
5215   tet_printf("Trace:%s \n", glSetUniformStack.GetTraceString().c_str());
5216
5217   // Test order of uniforms in stack
5218   indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3.000000");
5219   indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2.000000");
5220   indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1.000000");
5221
5222   tet_infoline("Testing C above A and B at bottom\n");
5223   bool CAB = (indexC > indexA) && (indexA > indexB);
5224
5225   DALI_TEST_EQUALS(CAB, true, TEST_LOCATION);
5226
5227   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5228   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
5229   DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
5230
5231   ResetTouchCallbacks();
5232
5233   END_TEST;
5234 }
5235
5236 int UtcDaliActorRaiseAbove(void)
5237 {
5238   tet_infoline("UtcDaliActor RaiseToAbove test \n");
5239
5240   TestApplication application;
5241
5242   Integration::Scene stage(application.GetScene());
5243
5244   Actor actorA = Actor::New();
5245   Actor actorB = Actor::New();
5246   Actor actorC = Actor::New();
5247
5248   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5249   actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5250
5251   actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5252   actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5253
5254   actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5255   actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5256
5257   actorA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5258   actorA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5259
5260   actorB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5261   actorB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5262
5263   actorC.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5264   actorC.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5265
5266   stage.Add(actorA);
5267   stage.Add(actorB);
5268   stage.Add(actorC);
5269
5270   ResetTouchCallbacks();
5271
5272   application.SendNotification();
5273   application.Render();
5274
5275   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5276   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
5277   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
5278
5279   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
5280   // Only top actor will get touched.
5281   actorA.TouchedSignal().Connect(TestTouchCallback);
5282   actorB.TouchedSignal().Connect(TestTouchCallback2);
5283   actorC.TouchedSignal().Connect(TestTouchCallback3);
5284
5285   bool                     orderChangedSignal(false);
5286   Actor                    orderChangedActor;
5287   ChildOrderChangedFunctor f(orderChangedSignal, orderChangedActor);
5288   DevelActor::ChildOrderChangedSignal(stage.GetRootLayer()).Connect(&application, f);
5289
5290   Dali::Integration::Point point;
5291   point.SetDeviceId(1);
5292   point.SetState(PointState::DOWN);
5293   point.SetScreenPosition(Vector2(10.f, 10.f));
5294   Dali::Integration::TouchEvent touchEvent;
5295   touchEvent.AddPoint(point);
5296
5297   application.ProcessEvent(touchEvent);
5298
5299   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5300   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
5301   DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
5302
5303   ResetTouchCallbacks();
5304
5305   tet_printf("Raise actor B Above Actor C\n");
5306
5307   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
5308   actorB.RaiseAbove(actorC);
5309   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
5310   DALI_TEST_EQUALS(orderChangedActor, actorB, TEST_LOCATION);
5311
5312   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5313   application.SendNotification();
5314   application.ProcessEvent(touchEvent);
5315
5316   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5317   DALI_TEST_EQUALS(gTouchCallBackCalled2, true, TEST_LOCATION);
5318   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
5319
5320   ResetTouchCallbacks();
5321
5322   tet_printf("Raise actor A Above Actor B\n");
5323
5324   orderChangedSignal = false;
5325
5326   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
5327   actorA.RaiseAbove(actorB);
5328   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
5329   DALI_TEST_EQUALS(orderChangedActor, actorA, TEST_LOCATION);
5330
5331   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5332   application.SendNotification();
5333
5334   application.ProcessEvent(touchEvent); // process a touch event on ordered actors.
5335
5336   DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
5337   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
5338   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
5339
5340   ResetTouchCallbacks();
5341
5342   END_TEST;
5343 }
5344
5345 int UtcDaliActorRaiseAbove2(void)
5346 {
5347   tet_infoline("UtcDaliActor RaiseToAbove test using SIBLING_ORDER property\n");
5348
5349   TestApplication application;
5350
5351   Integration::Scene stage(application.GetScene());
5352
5353   Actor actorA = Actor::New();
5354   Actor actorB = Actor::New();
5355   Actor actorC = Actor::New();
5356
5357   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5358   actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5359
5360   actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5361   actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5362
5363   actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5364   actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5365
5366   actorA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5367   actorA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5368
5369   actorB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5370   actorB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5371
5372   actorC.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5373   actorC.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5374
5375   stage.Add(actorA);
5376   stage.Add(actorB);
5377   stage.Add(actorC);
5378
5379   ResetTouchCallbacks();
5380
5381   application.SendNotification();
5382   application.Render();
5383
5384   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5385   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
5386   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
5387
5388   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
5389   // Only top actor will get touched.
5390   actorA.TouchedSignal().Connect(TestTouchCallback);
5391   actorB.TouchedSignal().Connect(TestTouchCallback2);
5392   actorC.TouchedSignal().Connect(TestTouchCallback3);
5393
5394   bool                     orderChangedSignal(false);
5395   Actor                    orderChangedActor;
5396   ChildOrderChangedFunctor f(orderChangedSignal, orderChangedActor);
5397   DevelActor::ChildOrderChangedSignal(stage.GetRootLayer()).Connect(&application, f);
5398
5399   Dali::Integration::Point point;
5400   point.SetDeviceId(1);
5401   point.SetState(PointState::DOWN);
5402   point.SetScreenPosition(Vector2(10.f, 10.f));
5403   Dali::Integration::TouchEvent touchEvent;
5404   touchEvent.AddPoint(point);
5405
5406   application.ProcessEvent(touchEvent);
5407
5408   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5409   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
5410   DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
5411
5412   ResetTouchCallbacks();
5413
5414   tet_printf("Raise actor B Above Actor C\n");
5415
5416   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
5417   int newOrder                                = actorC[DevelActor::Property::SIBLING_ORDER];
5418   actorB[DevelActor::Property::SIBLING_ORDER] = newOrder;
5419   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
5420   DALI_TEST_EQUALS(orderChangedActor, actorB, TEST_LOCATION);
5421
5422   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5423   application.SendNotification();
5424   application.ProcessEvent(touchEvent);
5425
5426   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5427   DALI_TEST_EQUALS(gTouchCallBackCalled2, true, TEST_LOCATION);
5428   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
5429
5430   ResetTouchCallbacks();
5431
5432   tet_printf("Raise actor A Above Actor B\n");
5433
5434   orderChangedSignal = false;
5435
5436   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
5437   newOrder                                    = actorB[DevelActor::Property::SIBLING_ORDER];
5438   actorA[DevelActor::Property::SIBLING_ORDER] = newOrder;
5439   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
5440   DALI_TEST_EQUALS(orderChangedActor, actorA, TEST_LOCATION);
5441
5442   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5443   application.SendNotification();
5444
5445   application.ProcessEvent(touchEvent); // process a touch event on ordered actors.
5446
5447   DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
5448   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
5449   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
5450
5451   ResetTouchCallbacks();
5452
5453   END_TEST;
5454 }
5455
5456 int UtcDaliActorLowerBelow(void)
5457 {
5458   tet_infoline("UtcDaliActor LowerBelow test \n");
5459
5460   TestApplication application;
5461
5462   Integration::Scene stage(application.GetScene());
5463
5464   // Set up renderers to add to Actors, float value 1, 2, 3 assigned to each
5465   // enables checking of which actor the uniform is assigned too
5466   Shader shaderA = CreateShader();
5467   shaderA.RegisterProperty("uRendererColor", 1.f);
5468
5469   Shader shaderB = CreateShader();
5470   shaderB.RegisterProperty("uRendererColor", 2.f);
5471
5472   Shader shaderC = CreateShader();
5473   shaderC.RegisterProperty("uRendererColor", 3.f);
5474
5475   Actor actorA = Actor::New();
5476   Actor actorB = Actor::New();
5477   Actor actorC = Actor::New();
5478
5479   // Add renderers to Actors so ( uRendererColor, 1 ) is A, ( uRendererColor, 2 ) is B, and ( uRendererColor, 3 ) is C,
5480   Geometry geometry = CreateQuadGeometry();
5481
5482   Renderer rendererA = Renderer::New(geometry, shaderA);
5483   actorA.AddRenderer(rendererA);
5484
5485   Renderer rendererB = Renderer::New(geometry, shaderB);
5486   actorB.AddRenderer(rendererB);
5487
5488   Renderer rendererC = Renderer::New(geometry, shaderC);
5489   actorC.AddRenderer(rendererC);
5490
5491   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5492   actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5493
5494   actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5495   actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5496
5497   actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5498   actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5499
5500   actorA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5501   actorA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5502
5503   actorB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5504   actorB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5505
5506   actorC.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5507   actorC.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5508
5509   Actor container = Actor::New();
5510   container.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5511   container.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
5512   stage.Add(container);
5513
5514   container.Add(actorA);
5515   container.Add(actorB);
5516   container.Add(actorC);
5517
5518   ResetTouchCallbacks();
5519
5520   // Connect ChildOrderChangedSignal
5521   bool                     orderChangedSignal(false);
5522   Actor                    orderChangedActor;
5523   ChildOrderChangedFunctor f(orderChangedSignal, orderChangedActor);
5524   DevelActor::ChildOrderChangedSignal(container).Connect(&application, f);
5525
5526   // Set up gl abstraction trace so can query the set uniform order
5527   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
5528   glAbstraction.EnableSetUniformCallTrace(true);
5529   glAbstraction.ResetSetUniformCallStack();
5530   TraceCallStack& glSetUniformStack = glAbstraction.GetSetUniformTrace();
5531
5532   glAbstraction.ResetSetUniformCallStack();
5533
5534   application.SendNotification();
5535   application.Render();
5536
5537   tet_printf("Trace:%s \n", glSetUniformStack.GetTraceString().c_str());
5538
5539   // Test order of uniforms in stack
5540   int indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3.000000");
5541   int indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2.000000");
5542   int indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1.000000");
5543
5544   tet_infoline("Testing C above B and A at bottom\n");
5545   bool CBA = (indexC > indexB) && (indexB > indexA);
5546
5547   DALI_TEST_EQUALS(CBA, true, TEST_LOCATION);
5548
5549   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5550   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
5551   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
5552
5553   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
5554   // Only top actor will get touched.
5555   actorA.TouchedSignal().Connect(TestTouchCallback);
5556   actorB.TouchedSignal().Connect(TestTouchCallback2);
5557   actorC.TouchedSignal().Connect(TestTouchCallback3);
5558
5559   Dali::Integration::Point point;
5560   point.SetDeviceId(1);
5561   point.SetState(PointState::DOWN);
5562   point.SetScreenPosition(Vector2(10.f, 10.f));
5563   Dali::Integration::TouchEvent touchEvent;
5564   touchEvent.AddPoint(point);
5565
5566   tet_infoline("UtcDaliActor Test Set up completed \n");
5567
5568   application.ProcessEvent(touchEvent);
5569
5570   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5571   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
5572   DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
5573
5574   ResetTouchCallbacks();
5575
5576   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");
5577
5578   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
5579   actorC.LowerBelow(actorB);
5580   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
5581   DALI_TEST_EQUALS(orderChangedActor, actorC, TEST_LOCATION);
5582
5583   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5584   application.SendNotification();
5585   application.Render();
5586
5587   application.ProcessEvent(touchEvent); // touch event
5588
5589   glSetUniformStack.Reset();
5590
5591   application.SendNotification();
5592   application.Render();
5593
5594   tet_printf("Trace:%s \n", glSetUniformStack.GetTraceString().c_str());
5595
5596   // Test order of uniforms in stack
5597   indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3.000000");
5598   indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2.000000");
5599   indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1.000000");
5600
5601   tet_infoline("Testing render order is A, C, B");
5602   DALI_TEST_EQUALS(indexC > indexA, true, TEST_LOCATION);
5603   DALI_TEST_EQUALS(indexB > indexC, true, TEST_LOCATION);
5604
5605   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5606   DALI_TEST_EQUALS(gTouchCallBackCalled2, true, TEST_LOCATION);
5607   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
5608
5609   ResetTouchCallbacks();
5610
5611   tet_printf("Lower actor C below Actor A leaving B on top\n");
5612
5613   orderChangedSignal = false;
5614
5615   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
5616   actorC.LowerBelow(actorA);
5617   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
5618   DALI_TEST_EQUALS(orderChangedActor, actorC, TEST_LOCATION);
5619
5620   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5621   application.SendNotification();
5622   application.Render();
5623
5624   application.ProcessEvent(touchEvent);
5625
5626   glSetUniformStack.Reset();
5627
5628   application.Render();
5629   tet_printf("Trace:%s \n", glSetUniformStack.GetTraceString().c_str());
5630
5631   // Test order of uniforms in stack
5632   indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3.000000");
5633   indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2.000000");
5634   indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1.000000");
5635
5636   DALI_TEST_EQUALS(indexA > indexC, true, TEST_LOCATION);
5637   DALI_TEST_EQUALS(indexB > indexA, true, TEST_LOCATION);
5638
5639   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5640   DALI_TEST_EQUALS(gTouchCallBackCalled2, true, TEST_LOCATION);
5641   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
5642
5643   ResetTouchCallbacks();
5644
5645   tet_printf("Lower actor B below Actor C leaving A on top\n");
5646
5647   orderChangedSignal = false;
5648
5649   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
5650   actorB.LowerBelow(actorC);
5651   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
5652   DALI_TEST_EQUALS(orderChangedActor, actorB, TEST_LOCATION);
5653
5654   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5655   application.SendNotification();
5656   application.Render();
5657
5658   application.ProcessEvent(touchEvent);
5659
5660   glSetUniformStack.Reset();
5661
5662   application.Render();
5663   tet_printf("Trace:%s \n", glSetUniformStack.GetTraceString().c_str());
5664
5665   // Test order of uniforms in stack
5666   indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3.000000");
5667   indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2.000000");
5668   indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1.000000");
5669
5670   DALI_TEST_EQUALS(indexC > indexB, true, TEST_LOCATION);
5671   DALI_TEST_EQUALS(indexA > indexC, true, TEST_LOCATION);
5672
5673   END_TEST;
5674 }
5675
5676 int UtcDaliActorLowerBelow2(void)
5677 {
5678   tet_infoline("UtcDaliActor LowerBelow test using SIBLING_ORDER property\n");
5679
5680   TestApplication application;
5681
5682   Integration::Scene stage(application.GetScene());
5683
5684   // Set up renderers to add to Actors, float value 1, 2, 3 assigned to each
5685   // enables checking of which actor the uniform is assigned too
5686   Shader shaderA = CreateShader();
5687   shaderA.RegisterProperty("uRendererColor", 1.f);
5688
5689   Shader shaderB = CreateShader();
5690   shaderB.RegisterProperty("uRendererColor", 2.f);
5691
5692   Shader shaderC = CreateShader();
5693   shaderC.RegisterProperty("uRendererColor", 3.f);
5694
5695   Actor actorA = Actor::New();
5696   Actor actorB = Actor::New();
5697   Actor actorC = Actor::New();
5698
5699   // Add renderers to Actors so ( uRendererColor, 1 ) is A, ( uRendererColor, 2 ) is B, and ( uRendererColor, 3 ) is C,
5700   Geometry geometry = CreateQuadGeometry();
5701
5702   Renderer rendererA = Renderer::New(geometry, shaderA);
5703   actorA.AddRenderer(rendererA);
5704
5705   Renderer rendererB = Renderer::New(geometry, shaderB);
5706   actorB.AddRenderer(rendererB);
5707
5708   Renderer rendererC = Renderer::New(geometry, shaderC);
5709   actorC.AddRenderer(rendererC);
5710
5711   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5712   actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5713
5714   actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5715   actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5716
5717   actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5718   actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5719
5720   actorA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5721   actorA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5722
5723   actorB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5724   actorB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5725
5726   actorC.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5727   actorC.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5728
5729   Actor container = Actor::New();
5730   container.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5731   container.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
5732   stage.Add(container);
5733
5734   container.Add(actorA);
5735   container.Add(actorB);
5736   container.Add(actorC);
5737
5738   ResetTouchCallbacks();
5739
5740   // Connect ChildOrderChangedSignal
5741   bool                     orderChangedSignal(false);
5742   Actor                    orderChangedActor;
5743   ChildOrderChangedFunctor f(orderChangedSignal, orderChangedActor);
5744   DevelActor::ChildOrderChangedSignal(container).Connect(&application, f);
5745
5746   // Set up gl abstraction trace so can query the set uniform order
5747   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
5748   glAbstraction.EnableSetUniformCallTrace(true);
5749   glAbstraction.ResetSetUniformCallStack();
5750   TraceCallStack& glSetUniformStack = glAbstraction.GetSetUniformTrace();
5751
5752   glAbstraction.ResetSetUniformCallStack();
5753
5754   application.SendNotification();
5755   application.Render();
5756
5757   tet_printf("Trace:%s \n", glSetUniformStack.GetTraceString().c_str());
5758
5759   // Test order of uniforms in stack
5760   int indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3.000000");
5761   int indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2.000000");
5762   int indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1.000000");
5763
5764   tet_infoline("Testing C above B and A at bottom\n");
5765   bool CBA = (indexC > indexB) && (indexB > indexA);
5766
5767   DALI_TEST_EQUALS(CBA, true, TEST_LOCATION);
5768
5769   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5770   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
5771   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
5772
5773   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
5774   // Only top actor will get touched.
5775   actorA.TouchedSignal().Connect(TestTouchCallback);
5776   actorB.TouchedSignal().Connect(TestTouchCallback2);
5777   actorC.TouchedSignal().Connect(TestTouchCallback3);
5778
5779   Dali::Integration::Point point;
5780   point.SetDeviceId(1);
5781   point.SetState(PointState::DOWN);
5782   point.SetScreenPosition(Vector2(10.f, 10.f));
5783   Dali::Integration::TouchEvent touchEvent;
5784   touchEvent.AddPoint(point);
5785
5786   tet_infoline("UtcDaliActor Test Set up completed \n");
5787
5788   application.ProcessEvent(touchEvent);
5789
5790   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5791   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
5792   DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
5793
5794   ResetTouchCallbacks();
5795
5796   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");
5797
5798   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
5799   actorC[DevelActor::Property::SIBLING_ORDER] = 1;
5800   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
5801   DALI_TEST_EQUALS(orderChangedActor, actorC, TEST_LOCATION);
5802
5803   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5804   application.SendNotification();
5805   application.Render();
5806
5807   application.ProcessEvent(touchEvent); // touch event
5808
5809   glSetUniformStack.Reset();
5810
5811   application.SendNotification();
5812   application.Render();
5813
5814   tet_printf("Trace:%s \n", glSetUniformStack.GetTraceString().c_str());
5815
5816   // Test order of uniforms in stack
5817   indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3.000000");
5818   indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2.000000");
5819   indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1.000000");
5820
5821   tet_infoline("Testing render order is A, C, B");
5822   DALI_TEST_EQUALS(indexC > indexA, true, TEST_LOCATION);
5823   DALI_TEST_EQUALS(indexB > indexC, true, TEST_LOCATION);
5824
5825   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5826   DALI_TEST_EQUALS(gTouchCallBackCalled2, true, TEST_LOCATION);
5827   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
5828
5829   ResetTouchCallbacks();
5830
5831   tet_printf("Lower actor C below Actor A leaving B on top\n");
5832
5833   orderChangedSignal = false;
5834
5835   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
5836   actorC[DevelActor::Property::SIBLING_ORDER] = 0;
5837   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
5838   DALI_TEST_EQUALS(orderChangedActor, actorC, TEST_LOCATION);
5839
5840   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5841   application.SendNotification();
5842   application.Render();
5843
5844   application.ProcessEvent(touchEvent);
5845
5846   glSetUniformStack.Reset();
5847
5848   application.Render();
5849   tet_printf("Trace:%s \n", glSetUniformStack.GetTraceString().c_str());
5850
5851   // Test order of uniforms in stack
5852   indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3.000000");
5853   indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2.000000");
5854   indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1.000000");
5855
5856   DALI_TEST_EQUALS(indexA > indexC, true, TEST_LOCATION);
5857   DALI_TEST_EQUALS(indexB > indexA, true, TEST_LOCATION);
5858
5859   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5860   DALI_TEST_EQUALS(gTouchCallBackCalled2, true, TEST_LOCATION);
5861   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
5862
5863   ResetTouchCallbacks();
5864
5865   tet_printf("Lower actor B below Actor C leaving A on top\n");
5866
5867   orderChangedSignal = false;
5868
5869   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
5870   actorB[DevelActor::Property::SIBLING_ORDER] = 0;
5871   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
5872   DALI_TEST_EQUALS(orderChangedActor, actorB, TEST_LOCATION);
5873
5874   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5875   application.SendNotification();
5876   application.Render();
5877
5878   application.ProcessEvent(touchEvent);
5879
5880   glSetUniformStack.Reset();
5881
5882   application.Render();
5883   tet_printf("Trace:%s \n", glSetUniformStack.GetTraceString().c_str());
5884
5885   // Test order of uniforms in stack
5886   indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3.000000");
5887   indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2.000000");
5888   indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1.000000");
5889
5890   DALI_TEST_EQUALS(indexC > indexB, true, TEST_LOCATION);
5891   DALI_TEST_EQUALS(indexA > indexC, true, TEST_LOCATION);
5892
5893   END_TEST;
5894 }
5895
5896 int UtcDaliActorRaiseAboveDifferentParentsN(void)
5897 {
5898   tet_infoline("UtcDaliActor RaiseToAbove test with actor and target actor having different parents \n");
5899
5900   TestApplication application;
5901
5902   Integration::Scene stage(application.GetScene());
5903
5904   Actor parentA = Actor::New();
5905   Actor parentB = Actor::New();
5906   parentA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5907   parentA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5908   parentB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5909   parentB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5910
5911   parentA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5912   parentA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5913
5914   parentB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5915   parentB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5916
5917   stage.Add(parentA);
5918   stage.Add(parentB);
5919
5920   Actor actorA = Actor::New();
5921   Actor actorB = Actor::New();
5922   Actor actorC = Actor::New();
5923
5924   parentA.Add(actorA);
5925   parentA.Add(actorB);
5926
5927   tet_printf("Actor C added to different parent from A and B \n");
5928   parentB.Add(actorC);
5929
5930   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5931   actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5932
5933   actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5934   actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5935
5936   actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
5937   actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
5938
5939   actorA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5940   actorA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5941
5942   actorB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5943   actorB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5944
5945   actorC.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
5946   actorC.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
5947
5948   ResetTouchCallbacks();
5949
5950   // Connect ChildOrderChangedSignal
5951   bool                     orderChangedSignal(false);
5952   Actor                    orderChangedActor;
5953   ChildOrderChangedFunctor f(orderChangedSignal, orderChangedActor);
5954   DevelActor::ChildOrderChangedSignal(stage.GetRootLayer()).Connect(&application, f);
5955
5956   application.SendNotification();
5957   application.Render();
5958
5959   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5960   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
5961   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
5962
5963   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
5964   // Only top actor will get touched.
5965   actorA.TouchedSignal().Connect(TestTouchCallback);
5966   actorB.TouchedSignal().Connect(TestTouchCallback2);
5967   actorC.TouchedSignal().Connect(TestTouchCallback3);
5968
5969   Dali::Integration::Point point;
5970   point.SetDeviceId(1);
5971   point.SetState(PointState::DOWN);
5972   point.SetScreenPosition(Vector2(10.f, 10.f));
5973   Dali::Integration::TouchEvent touchEvent;
5974   touchEvent.AddPoint(point);
5975
5976   application.ProcessEvent(touchEvent);
5977
5978   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5979   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
5980   DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
5981
5982   ResetTouchCallbacks();
5983
5984   tet_printf("Raise actor A Above Actor C which have different parents\n");
5985
5986   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
5987   actorA.RaiseAbove(actorC);
5988   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
5989
5990   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5991   application.SendNotification();
5992
5993   application.ProcessEvent(touchEvent); // touch event
5994
5995   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
5996   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
5997   DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
5998
5999   ResetTouchCallbacks();
6000
6001   END_TEST;
6002 }
6003
6004 int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void)
6005 {
6006   tet_infoline("UtcDaliActor Test  raiseAbove and lowerBelow api when target Actor has no parent \n");
6007
6008   TestApplication application;
6009
6010   Integration::Scene stage(application.GetScene());
6011
6012   Actor actorA = Actor::New();
6013   Actor actorB = Actor::New();
6014   Actor actorC = Actor::New();
6015
6016   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
6017   actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6018
6019   actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
6020   actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6021
6022   actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
6023   actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6024
6025   actorA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
6026   actorA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
6027
6028   actorB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
6029   actorB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
6030
6031   actorC.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
6032   actorC.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
6033
6034   ResetTouchCallbacks();
6035
6036   // Connect ChildOrderChangedSignal
6037   bool                     orderChangedSignal(false);
6038   Actor                    orderChangedActor;
6039   ChildOrderChangedFunctor f(orderChangedSignal, orderChangedActor);
6040   DevelActor::ChildOrderChangedSignal(stage.GetRootLayer()).Connect(&application, f);
6041
6042   application.SendNotification();
6043   application.Render();
6044
6045   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
6046   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
6047   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
6048
6049   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
6050   // Only top actor will get touched.
6051   actorA.TouchedSignal().Connect(TestTouchCallback);
6052   actorB.TouchedSignal().Connect(TestTouchCallback2);
6053   actorC.TouchedSignal().Connect(TestTouchCallback3);
6054
6055   Dali::Integration::Point point;
6056   point.SetDeviceId(1);
6057   point.SetState(PointState::DOWN);
6058   point.SetScreenPosition(Vector2(10.f, 10.f));
6059   Dali::Integration::TouchEvent touchEvent;
6060   touchEvent.AddPoint(point);
6061
6062   tet_printf("Raise actor A Above Actor C which have no parents\n");
6063
6064   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6065   actorA.RaiseAbove(actorC);
6066   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6067
6068   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
6069   application.SendNotification();
6070
6071   application.ProcessEvent(touchEvent);
6072
6073   tet_printf("Not parented so RaiseAbove should show no effect\n");
6074
6075   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
6076   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
6077   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
6078
6079   ResetTouchCallbacks();
6080
6081   orderChangedSignal = false;
6082
6083   stage.Add(actorB);
6084   tet_printf("Lower actor A below Actor C when only A is not on stage \n");
6085
6086   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6087   actorA.LowerBelow(actorC);
6088   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6089
6090   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
6091   application.SendNotification();
6092   application.Render();
6093
6094   application.ProcessEvent(touchEvent);
6095
6096   tet_printf("Actor A not parented so LowerBelow should show no effect\n");
6097   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
6098   DALI_TEST_EQUALS(gTouchCallBackCalled2, true, TEST_LOCATION);
6099   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
6100
6101   ResetTouchCallbacks();
6102
6103   orderChangedSignal = false;
6104
6105   tet_printf("Adding Actor A to stage, will be on top\n");
6106
6107   stage.Add(actorA);
6108   application.SendNotification();
6109   application.Render();
6110
6111   tet_printf("Raise actor B Above Actor C when only B has a parent\n");
6112
6113   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6114   actorB.RaiseAbove(actorC);
6115   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6116
6117   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
6118   application.SendNotification();
6119
6120   application.ProcessEvent(touchEvent);
6121
6122   tet_printf("C not parented so RaiseAbove should show no effect\n");
6123   DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
6124   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
6125   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
6126
6127   ResetTouchCallbacks();
6128
6129   orderChangedSignal = false;
6130
6131   tet_printf("Lower actor A below Actor C when only A has a parent\n");
6132
6133   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6134   actorA.LowerBelow(actorC);
6135   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6136
6137   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
6138   application.SendNotification();
6139
6140   application.ProcessEvent(touchEvent);
6141
6142   tet_printf("C not parented so LowerBelow should show no effect\n");
6143   DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
6144   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
6145   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
6146
6147   ResetTouchCallbacks();
6148
6149   orderChangedSignal = false;
6150
6151   stage.Add(actorC);
6152
6153   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6154   actorA.RaiseAbove(actorC);
6155   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
6156   DALI_TEST_EQUALS(orderChangedActor, actorA, TEST_LOCATION);
6157
6158   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
6159   application.SendNotification();
6160   application.Render();
6161
6162   application.ProcessEvent(touchEvent);
6163
6164   tet_printf("Raise actor A Above Actor C, now both have same parent \n");
6165   DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
6166   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
6167   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
6168
6169   END_TEST;
6170 }
6171
6172 int UtcDaliActorTestAllAPIwhenActorNotParented(void)
6173 {
6174   tet_infoline("UtcDaliActor Test all raise/lower api when actor has no parent \n");
6175
6176   TestApplication application;
6177
6178   Integration::Scene stage(application.GetScene());
6179
6180   Actor actorA = Actor::New();
6181   Actor actorB = Actor::New();
6182   Actor actorC = Actor::New();
6183
6184   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
6185   actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6186
6187   actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
6188   actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6189
6190   actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
6191   actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6192
6193   actorA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
6194   actorA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
6195
6196   actorB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
6197   actorB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
6198
6199   actorC.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
6200   actorC.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
6201
6202   ResetTouchCallbacks();
6203
6204   // Connect ChildOrderChangedSignal
6205   bool                     orderChangedSignal(false);
6206   Actor                    orderChangedActor;
6207   ChildOrderChangedFunctor f(orderChangedSignal, orderChangedActor);
6208   DevelActor::ChildOrderChangedSignal(stage.GetRootLayer()).Connect(&application, f);
6209
6210   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
6211   // Only top actor will get touched.
6212   actorA.TouchedSignal().Connect(TestTouchCallback);
6213   actorB.TouchedSignal().Connect(TestTouchCallback2);
6214   actorC.TouchedSignal().Connect(TestTouchCallback3);
6215
6216   Dali::Integration::Point point;
6217   point.SetDeviceId(1);
6218   point.SetState(PointState::DOWN);
6219   point.SetScreenPosition(Vector2(10.f, 10.f));
6220   Dali::Integration::TouchEvent touchEvent;
6221   touchEvent.AddPoint(point);
6222
6223   stage.Add(actorA);
6224   tet_printf("Raise actor B Above Actor C but B not parented\n");
6225
6226   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6227   actorB.Raise();
6228   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6229
6230   application.SendNotification();
6231   application.Render();
6232
6233   application.ProcessEvent(touchEvent);
6234
6235   tet_printf("Not parented so RaiseAbove should show no effect\n");
6236
6237   DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
6238   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
6239   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
6240
6241   tet_printf("Raise actor B Above Actor C but B not parented\n");
6242   ResetTouchCallbacks();
6243
6244   orderChangedSignal = false;
6245
6246   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6247   actorC.Lower();
6248   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6249
6250   // Sort actor tree before next touch event
6251   application.SendNotification();
6252   application.Render();
6253
6254   application.ProcessEvent(touchEvent);
6255
6256   tet_printf("Not parented so RaiseAbove should show no effect\n");
6257
6258   DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
6259   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
6260   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
6261   ResetTouchCallbacks();
6262
6263   orderChangedSignal = false;
6264
6265   tet_printf("Lower actor C below B but C not parented\n");
6266
6267   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6268   actorB.Lower();
6269   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6270
6271   // Sort actor tree before next touch event
6272   application.SendNotification();
6273   application.Render();
6274
6275   application.ProcessEvent(touchEvent);
6276
6277   tet_printf("Not parented so Lower should show no effect\n");
6278
6279   DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
6280   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
6281   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
6282   ResetTouchCallbacks();
6283
6284   orderChangedSignal = false;
6285
6286   tet_printf("Raise actor B to top\n");
6287
6288   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6289   actorB.RaiseToTop();
6290   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6291
6292   // Sort actor tree before next touch event
6293   application.SendNotification();
6294   application.Render();
6295
6296   application.ProcessEvent(touchEvent);
6297
6298   tet_printf("Not parented so RaiseToTop should show no effect\n");
6299
6300   DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
6301   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
6302   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
6303   ResetTouchCallbacks();
6304
6305   orderChangedSignal = false;
6306
6307   tet_printf("Add ActorB to stage so only Actor C not parented\n");
6308
6309   stage.Add(actorB);
6310
6311   tet_printf("Lower actor C to Bottom, B stays at top\n");
6312
6313   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6314   actorC.LowerToBottom();
6315   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6316
6317   application.SendNotification();
6318   application.Render();
6319
6320   application.ProcessEvent(touchEvent);
6321
6322   tet_printf("Not parented so LowerToBottom should show no effect\n");
6323
6324   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
6325   DALI_TEST_EQUALS(gTouchCallBackCalled2, true, TEST_LOCATION);
6326   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
6327   ResetTouchCallbacks();
6328
6329   END_TEST;
6330 }
6331
6332 int UtcDaliActorRaiseAboveActorAndTargetTheSameN(void)
6333 {
6334   tet_infoline("UtcDaliActor RaiseToAbove and  test with actor provided as target resulting in a no operation \n");
6335
6336   TestApplication application;
6337
6338   Integration::Scene stage(application.GetScene());
6339
6340   Actor actorA = Actor::New();
6341   Actor actorB = Actor::New();
6342   Actor actorC = Actor::New();
6343
6344   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
6345   actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6346
6347   actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
6348   actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6349
6350   actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
6351   actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6352
6353   actorA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
6354   actorA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
6355
6356   actorB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
6357   actorB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
6358
6359   actorC.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
6360   actorC.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
6361
6362   stage.Add(actorA);
6363   stage.Add(actorB);
6364   stage.Add(actorC);
6365
6366   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
6367   // Only top actor will get touched.
6368   actorA.TouchedSignal().Connect(TestTouchCallback);
6369   actorB.TouchedSignal().Connect(TestTouchCallback2);
6370   actorC.TouchedSignal().Connect(TestTouchCallback3);
6371
6372   ResetTouchCallbacks();
6373
6374   // Connect ChildOrderChangedSignal
6375   bool                     orderChangedSignal(false);
6376   Actor                    orderChangedActor;
6377   ChildOrderChangedFunctor f(orderChangedSignal, orderChangedActor);
6378   DevelActor::ChildOrderChangedSignal(stage.GetRootLayer()).Connect(&application, f);
6379
6380   application.SendNotification();
6381   application.Render();
6382
6383   Dali::Integration::Point point;
6384   point.SetDeviceId(1);
6385   point.SetState(PointState::DOWN);
6386   point.SetScreenPosition(Vector2(10.f, 10.f));
6387   Dali::Integration::TouchEvent touchEvent;
6388   touchEvent.AddPoint(point);
6389
6390   application.ProcessEvent(touchEvent);
6391
6392   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
6393   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
6394   DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
6395
6396   ResetTouchCallbacks();
6397
6398   tet_infoline("Raise actor A Above Actor A which is the same actor!!\n");
6399
6400   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6401   actorA.RaiseAbove(actorA);
6402   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
6403   DALI_TEST_EQUALS(orderChangedActor, actorA, TEST_LOCATION);
6404
6405   application.SendNotification();
6406   application.Render();
6407
6408   application.ProcessEvent(touchEvent);
6409
6410   tet_infoline("No target is source Actor so RaiseAbove should show no effect\n");
6411
6412   DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
6413   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
6414   DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
6415
6416   ResetTouchCallbacks();
6417
6418   orderChangedSignal = false;
6419
6420   DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
6421   actorA.RaiseAbove(actorC);
6422   DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
6423   DALI_TEST_EQUALS(orderChangedActor, actorA, TEST_LOCATION);
6424
6425   application.SendNotification();
6426   application.Render();
6427
6428   application.ProcessEvent(touchEvent);
6429
6430   tet_infoline("Raise actor A Above Actor C which will now be successful \n");
6431   DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
6432   DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
6433   DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
6434
6435   END_TEST;
6436 }
6437
6438 int UtcDaliActorGetScreenPosition(void)
6439 {
6440   tet_infoline("UtcDaliActorGetScreenPosition Get screen coordinates of Actor \n");
6441
6442   TestApplication application;
6443
6444   Integration::Scene stage(application.GetScene());
6445
6446   Actor actorA = Actor::New();
6447   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
6448
6449   Vector2 size2(10.0f, 20.0f);
6450   actorA.SetProperty(Actor::Property::SIZE, size2);
6451
6452   actorA.SetProperty(Actor::Property::POSITION, Vector2(0.f, 0.f));
6453
6454   tet_infoline("UtcDaliActorGetScreenPosition Center Anchor Point and 0,0 position \n");
6455
6456   stage.Add(actorA);
6457
6458   application.SendNotification();
6459   application.Render();
6460
6461   Vector3 actorWorldPosition  = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
6462   Vector2 actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
6463
6464   tet_printf("Actor World Position ( %f %f ) AnchorPoint::CENTER \n", actorWorldPosition.x, actorWorldPosition.y);
6465   tet_printf("Actor Screen Position %f %f \n", actorScreenPosition.x, actorScreenPosition.y);
6466
6467   DALI_TEST_EQUALS(actorScreenPosition.x, 0lu, TEST_LOCATION);
6468   DALI_TEST_EQUALS(actorScreenPosition.y, 0lu, TEST_LOCATION);
6469
6470   tet_infoline("UtcDaliActorGetScreenPosition Top Left Anchor Point and 0,0 position \n");
6471
6472   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
6473
6474   application.SendNotification();
6475   application.Render();
6476
6477   actorWorldPosition  = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
6478   actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
6479
6480   tet_printf("Actor World Position  ( %f %f ) AnchorPoint::TOP_LEFT  \n", actorWorldPosition.x, actorWorldPosition.y);
6481   tet_printf("Actor Screen Position  ( %f %f ) AnchorPoint::TOP_LEFT \n", actorScreenPosition.x, actorScreenPosition.y);
6482
6483   DALI_TEST_EQUALS(actorScreenPosition.x, 0lu, TEST_LOCATION);
6484   DALI_TEST_EQUALS(actorScreenPosition.y, 0lu, TEST_LOCATION);
6485
6486   tet_infoline("UtcDaliActorGetScreenPosition Bottom right Anchor Point and 0,0 position \n");
6487
6488   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
6489
6490   application.SendNotification();
6491   application.Render();
6492
6493   actorWorldPosition  = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
6494   actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
6495
6496   tet_printf("Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT   \n", actorWorldPosition.x, actorWorldPosition.y);
6497   tet_printf("Actor Screen Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT  \n", actorScreenPosition.x, actorScreenPosition.y);
6498
6499   DALI_TEST_EQUALS(actorScreenPosition.x, 0lu, TEST_LOCATION);
6500   DALI_TEST_EQUALS(actorScreenPosition.y, 0lu, TEST_LOCATION);
6501
6502   tet_infoline("UtcDaliActorGetScreenPosition Bottom right Anchor Point and 30,0 position \n");
6503
6504   actorA.SetProperty(Actor::Property::POSITION, Vector2(30.0, 0.0));
6505
6506   application.SendNotification();
6507   application.Render();
6508
6509   actorWorldPosition  = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
6510   actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
6511
6512   tet_printf("Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 0.0 \n", actorWorldPosition.x, actorWorldPosition.y);
6513   tet_printf("Actor Screen Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 0.0   \n", actorScreenPosition.x, actorScreenPosition.y);
6514
6515   DALI_TEST_EQUALS(actorScreenPosition.x, 30lu, TEST_LOCATION);
6516   DALI_TEST_EQUALS(actorScreenPosition.y, 0lu, TEST_LOCATION);
6517
6518   tet_infoline("UtcDaliActorGetScreenPosition Bottom right Anchor Point and 30,420 position \n");
6519
6520   actorA.SetProperty(Actor::Property::POSITION, Vector2(30.0, 420.0));
6521
6522   application.SendNotification();
6523   application.Render();
6524
6525   actorWorldPosition  = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
6526   actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
6527
6528   DALI_TEST_EQUALS(actorScreenPosition.x, 30lu, TEST_LOCATION);
6529   DALI_TEST_EQUALS(actorScreenPosition.y, 420lu, TEST_LOCATION);
6530
6531   tet_printf("Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 420.0\n", actorWorldPosition.x, actorWorldPosition.y);
6532   tet_printf("Actor Screen Position( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 420.0 \n", actorScreenPosition.x, actorScreenPosition.y);
6533
6534   tet_infoline("UtcDaliActorGetScreenPosition Scale parent and check child's screen position \n");
6535
6536   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
6537   actorA.SetProperty(Actor::Property::POSITION, Vector2(30.0, 30.0));
6538
6539   Actor actorB = Actor::New();
6540   actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
6541   actorB.SetProperty(Actor::Property::SIZE, size2);
6542   actorB.SetProperty(Actor::Property::POSITION, Vector2(10.f, 10.f));
6543   actorA.Add(actorB);
6544
6545   actorA.SetProperty(Actor::Property::SCALE, 2.0f);
6546
6547   application.SendNotification();
6548   application.Render();
6549
6550   actorScreenPosition = actorB.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
6551
6552   DALI_TEST_EQUALS(actorScreenPosition.x, 50lu, TEST_LOCATION);
6553   DALI_TEST_EQUALS(actorScreenPosition.y, 50lu, TEST_LOCATION);
6554
6555   END_TEST;
6556 }
6557
6558 int UtcDaliActorGetScreenPositionAfterScaling(void)
6559 {
6560   tet_infoline("UtcDaliActorGetScreenPositionAfterScaling Get screen coordinates of Actor \n");
6561
6562   TestApplication application;
6563
6564   Integration::Scene stage(application.GetScene());
6565
6566   Actor actorA = Actor::New();
6567   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
6568
6569   Vector2 size2(10.0f, 20.0f);
6570   actorA.SetProperty(Actor::Property::SIZE, size2);
6571   actorA.SetProperty(Actor::Property::SCALE, 1.5f);
6572   actorA.SetProperty(Actor::Property::POSITION, Vector2(0.f, 0.f));
6573
6574   tet_infoline("UtcDaliActorGetScreenPositionAfterScaling TopRight Anchor Point, scale 1.5f and 0,0 position \n");
6575
6576   stage.Add(actorA);
6577
6578   application.SendNotification();
6579   application.Render();
6580
6581   Vector3 actorWorldPosition  = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
6582   Vector2 actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
6583
6584   tet_printf("Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT \n", actorWorldPosition.x, actorWorldPosition.y);
6585   tet_printf("Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y);
6586
6587   DALI_TEST_EQUALS(actorScreenPosition.x, 0lu, TEST_LOCATION);
6588   DALI_TEST_EQUALS(actorScreenPosition.y, 0lu, TEST_LOCATION);
6589
6590   tet_infoline("UtcDaliActorGetScreenPositionAfterScaling BOTTOM_RIGHT Anchor Point, scale 1.5f and 0,0 position \n");
6591
6592   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
6593
6594   application.SendNotification();
6595   application.Render();
6596
6597   actorWorldPosition  = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
6598   actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
6599
6600   tet_printf("Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT \n", actorWorldPosition.x, actorWorldPosition.y);
6601   tet_printf("Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y);
6602
6603   DALI_TEST_EQUALS(actorScreenPosition.x, 0.0f, TEST_LOCATION);
6604   DALI_TEST_EQUALS(actorScreenPosition.y, 0.0f, TEST_LOCATION);
6605
6606   END_TEST;
6607 }
6608
6609 int UtcDaliActorGetScreenPositionWithDifferentParentOrigin(void)
6610 {
6611   tet_infoline("UtcDaliActorGetScreenPositionWithDifferentParentOrigin Changes parent origin which should not effect result \n");
6612
6613   TestApplication application;
6614
6615   Integration::Scene stage(application.GetScene());
6616
6617   Actor actorA = Actor::New();
6618   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
6619   actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6620   Vector2 size2(10.0f, 20.0f);
6621   actorA.SetProperty(Actor::Property::SIZE, size2);
6622   actorA.SetProperty(Actor::Property::POSITION, Vector2(0.f, 0.f));
6623
6624   tet_infoline(" TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n");
6625
6626   stage.Add(actorA);
6627
6628   application.SendNotification();
6629   application.Render();
6630
6631   Vector3 actorWorldPosition  = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
6632   Vector2 actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
6633
6634   tet_printf("Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER  \n", actorWorldPosition.x, actorWorldPosition.y);
6635   tet_printf("Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y);
6636
6637   DALI_TEST_EQUALS(actorScreenPosition.x, 240.0f, TEST_LOCATION);
6638   DALI_TEST_EQUALS(actorScreenPosition.y, 400.0f, TEST_LOCATION);
6639
6640   tet_infoline(" BOTTOM_RIGHT Anchor Point, ParentOrigin::TOP_RIGHT and 0,0 position \n");
6641
6642   actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_RIGHT);
6643   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
6644
6645   application.SendNotification();
6646   application.Render();
6647
6648   actorWorldPosition  = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
6649   actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
6650
6651   tet_printf("Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT ParentOrigin::TOP_RIGHT \n", actorWorldPosition.x, actorWorldPosition.y);
6652   tet_printf("Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y);
6653
6654   DALI_TEST_EQUALS(actorScreenPosition.x, 480.0f, TEST_LOCATION);
6655   DALI_TEST_EQUALS(actorScreenPosition.y, 0.0f, TEST_LOCATION);
6656
6657   END_TEST;
6658   END_TEST;
6659 }
6660
6661 int UtcDaliActorGetScreenPositionWithChildActors(void)
6662 {
6663   tet_infoline("UtcDaliActorGetScreenPositionWithChildActors Check screen position with a tree of actors \n");
6664
6665   TestApplication application;
6666
6667   Integration::Scene stage(application.GetScene());
6668
6669   tet_infoline("Create Child Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n");
6670
6671   Actor actorA = Actor::New();
6672   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
6673   actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6674   Vector2 size1(10.0f, 20.0f);
6675   actorA.SetProperty(Actor::Property::SIZE, size1);
6676   actorA.SetProperty(Actor::Property::POSITION, Vector2(0.f, 0.f));
6677
6678   tet_infoline("Create Parent Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n");
6679
6680   Actor parentActorA = Actor::New();
6681   parentActorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
6682   parentActorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6683   Vector2 size2(30.0f, 60.0f);
6684   parentActorA.SetProperty(Actor::Property::SIZE, size2);
6685   parentActorA.SetProperty(Actor::Property::POSITION, Vector2(0.f, 0.f));
6686
6687   tet_infoline("Add child 1 to Parent 1 and check screen position \n");
6688
6689   stage.Add(parentActorA);
6690   parentActorA.Add(actorA);
6691
6692   application.SendNotification();
6693   application.Render();
6694
6695   Vector3 actorWorldPosition  = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
6696   Vector2 actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
6697
6698   tet_printf("Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER  \n", actorWorldPosition.x, actorWorldPosition.y);
6699   tet_printf("Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y);
6700
6701   DALI_TEST_EQUALS(actorScreenPosition.x, 255.0f, TEST_LOCATION);
6702   DALI_TEST_EQUALS(actorScreenPosition.y, 430.0f, TEST_LOCATION);
6703
6704   tet_infoline("Test 2\n");
6705
6706   tet_infoline("change parent anchor point and parent origin then check screen position \n");
6707
6708   parentActorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_LEFT);
6709   parentActorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
6710
6711   application.SendNotification();
6712   application.Render();
6713
6714   actorWorldPosition  = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
6715   actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
6716
6717   tet_printf("Actor World Position ( %f %f ) AnchorPoint::BOTTOM_LEFT ParentOrigin::TOP_LEFT  \n", actorWorldPosition.x, actorWorldPosition.y);
6718   tet_printf("Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y);
6719
6720   DALI_TEST_EQUALS(actorScreenPosition.x, 15.0f, TEST_LOCATION);
6721   DALI_TEST_EQUALS(actorScreenPosition.y, -30.0f, TEST_LOCATION);
6722
6723   END_TEST;
6724 }
6725
6726 int UtcDaliActorGetScreenPositionWithChildActors02(void)
6727 {
6728   tet_infoline("UtcDaliActorGetScreenPositionWithChildActors02 Check screen position with a tree of actors \n");
6729
6730   TestApplication application;
6731
6732   Integration::Scene stage(application.GetScene());
6733
6734   tet_infoline("Create Child Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n");
6735
6736   Actor actorA = Actor::New();
6737   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
6738   actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6739   Vector2 size1(10.0f, 20.0f);
6740   actorA.SetProperty(Actor::Property::SIZE, size1);
6741   actorA.SetProperty(Actor::Property::POSITION, Vector2(0.f, 0.f));
6742
6743   tet_infoline("Create Parent Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n");
6744
6745   Actor parentActorA = Actor::New();
6746   parentActorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
6747   parentActorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6748   Vector2 size2(30.0f, 60.0f);
6749   parentActorA.SetProperty(Actor::Property::SIZE, size2);
6750   parentActorA.SetProperty(Actor::Property::POSITION, Vector2(0.f, 0.f));
6751
6752   tet_infoline("Create Grand Parent Actor 1 BOTTOM_LEFT Anchor Point, ParentOrigin::BOTTOM_LEFT and 0,0 position \n");
6753
6754   Actor grandParentActorA = Actor::New();
6755   grandParentActorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_LEFT);
6756   grandParentActorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_LEFT);
6757   Vector2 size3(60.0f, 120.0f);
6758   grandParentActorA.SetProperty(Actor::Property::SIZE, size3);
6759   grandParentActorA.SetProperty(Actor::Property::POSITION, Vector2(0.f, 0.f));
6760
6761   tet_infoline("Add Parent 1 to Grand Parent 1 \n");
6762
6763   stage.Add(grandParentActorA);
6764   grandParentActorA.Add(parentActorA);
6765
6766   tet_infoline("Add child 1 to Parent 1 and check screen position \n");
6767
6768   parentActorA.Add(actorA);
6769
6770   application.SendNotification();
6771   application.Render();
6772
6773   Vector3 actorWorldPosition  = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
6774   Vector2 actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
6775
6776   tet_printf("Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER  \n", actorWorldPosition.x, actorWorldPosition.y);
6777   tet_printf("Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y);
6778
6779   DALI_TEST_EQUALS(actorScreenPosition.x, 45.0f, TEST_LOCATION);
6780   DALI_TEST_EQUALS(actorScreenPosition.y, 770.0f, TEST_LOCATION);
6781
6782   END_TEST;
6783 }
6784
6785 int UtcDaliActorGetScreenPositionPositionUsesAnchorPointFalse(void)
6786 {
6787   tet_infoline("UtcDaliActorGetScreenPositionPositionUsesAnchorPointFalse Check screen position where the position does not use the anchor point");
6788
6789   TestApplication application;
6790
6791   Integration::Scene stage(application.GetScene());
6792
6793   tet_infoline("Create an actor with AnchorPoint::TOP_LEFT, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false");
6794
6795   Actor actorA = Actor::New();
6796   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
6797   actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6798   actorA.SetProperty(Actor::Property::POSITION_USES_ANCHOR_POINT, false);
6799   actorA.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 20.0f));
6800   stage.Add(actorA);
6801
6802   tet_infoline("Create an Actor with AnchorPoint::BOTTOM_RIGHT, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false");
6803
6804   Actor actorB = Actor::New();
6805   actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
6806   actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6807   actorB.SetProperty(Actor::Property::POSITION_USES_ANCHOR_POINT, false);
6808   Vector2 actorBSize(30.0f, 60.0f);
6809   actorB.SetProperty(Actor::Property::SIZE, actorBSize);
6810   stage.Add(actorB);
6811
6812   tet_infoline("Create an actor with AnchorPoint::CENTER, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false");
6813
6814   Actor actorC = Actor::New();
6815   actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
6816   actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6817   actorC.SetProperty(Actor::Property::POSITION_USES_ANCHOR_POINT, false);
6818   Vector2 actorCSize(60.0f, 120.0f);
6819   actorC.SetProperty(Actor::Property::SIZE, actorCSize);
6820   stage.Add(actorC);
6821
6822   application.SendNotification();
6823   application.Render();
6824
6825   tet_infoline("Despite differing sizes and anchor-points, the screen position for all actors is the same");
6826
6827   Vector2 center(stage.GetSize() * 0.5f);
6828
6829   DALI_TEST_EQUALS(actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>(), center, TEST_LOCATION);
6830   DALI_TEST_EQUALS(actorB.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>(), center, TEST_LOCATION);
6831   DALI_TEST_EQUALS(actorC.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>(), center, TEST_LOCATION);
6832
6833   tet_infoline("Add scale to all actors");
6834
6835   actorA.SetProperty(Actor::Property::SCALE, 2.0f);
6836   actorB.SetProperty(Actor::Property::SCALE, 2.0f);
6837   actorC.SetProperty(Actor::Property::SCALE, 2.0f);
6838
6839   application.SendNotification();
6840   application.Render();
6841
6842   DALI_TEST_EQUALS(actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>(), center /* TOP_LEFT Anchor */, TEST_LOCATION);
6843   DALI_TEST_EQUALS(actorB.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>(), center - actorBSize /* BOTTOM_RIGHT Anchor */, TEST_LOCATION);
6844   DALI_TEST_EQUALS(actorC.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>(), center - actorCSize * 0.5f /* CENTER Anchor*/, TEST_LOCATION);
6845
6846   END_TEST;
6847 }
6848
6849 int utcDaliActorPositionUsesAnchorPoint(void)
6850 {
6851   TestApplication application;
6852   tet_infoline("Check default behaviour\n");
6853
6854   Actor actor = Actor::New();
6855   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6856   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
6857   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
6858   application.GetScene().Add(actor);
6859
6860   application.SendNotification();
6861   application.Render();
6862
6863   tet_infoline("Check that the world position is in the center\n");
6864   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
6865
6866   tet_infoline("Set the position uses anchor point property to false\n");
6867   actor.SetProperty(Actor::Property::POSITION_USES_ANCHOR_POINT, false);
6868
6869   application.SendNotification();
6870   application.Render();
6871
6872   tet_infoline("Check that the world position has changed appropriately\n");
6873   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(50.0f, 50.0f, 0.0f), TEST_LOCATION);
6874
6875   END_TEST;
6876 }
6877
6878 int utcDaliActorPositionUsesAnchorPointCheckScale(void)
6879 {
6880   TestApplication application;
6881   tet_infoline("Check that the scale is adjusted appropriately when setting the positionUsesAnchorPoint to false\n");
6882
6883   Actor actor = Actor::New();
6884   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6885   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
6886   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
6887   actor.SetProperty(Actor::Property::SCALE, 2.0f);
6888   actor.SetProperty(Actor::Property::POSITION_USES_ANCHOR_POINT, false);
6889   application.GetScene().Add(actor);
6890
6891   application.SendNotification();
6892   application.Render();
6893
6894   tet_infoline("Check the world position is the same as it would be without a scale\n");
6895   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(50.0f, 50.0f, 0.0f), TEST_LOCATION);
6896
6897   tet_infoline("Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly");
6898   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
6899   application.SendNotification();
6900   application.Render();
6901   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(100.0f, 100.0f, 0.0f), TEST_LOCATION);
6902
6903   tet_infoline("Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly");
6904   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
6905   application.SendNotification();
6906   application.Render();
6907   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
6908
6909   END_TEST;
6910 }
6911
6912 int utcDaliActorPositionUsesAnchorPointCheckRotation(void)
6913 {
6914   TestApplication application;
6915   tet_infoline("Check that the rotation is adjusted appropriately when setting the positionUsesAnchorPoint to false\n");
6916
6917   Actor actor = Actor::New();
6918   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6919   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
6920   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
6921   actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Degree(90.0f), Vector3::ZAXIS));
6922   actor.SetProperty(Actor::Property::POSITION_USES_ANCHOR_POINT, false);
6923   application.GetScene().Add(actor);
6924
6925   application.SendNotification();
6926   application.Render();
6927
6928   tet_infoline("Check the world position is the same as it would be without a rotation\n");
6929   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(50.0f, 50.0f, 0.0f), TEST_LOCATION);
6930
6931   tet_infoline("Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly");
6932   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
6933   application.SendNotification();
6934   application.Render();
6935   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(-50.0f, 50.0f, 0.0f), TEST_LOCATION);
6936
6937   tet_infoline("Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly");
6938   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
6939   application.SendNotification();
6940   application.Render();
6941   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(150.0f, 50.0f, 0.0f), TEST_LOCATION);
6942
6943   END_TEST;
6944 }
6945
6946 int utcDaliActorPositionUsesAnchorPointCheckScaleAndRotation(void)
6947 {
6948   TestApplication application;
6949   tet_infoline("Check that the scale and rotation is adjusted appropriately when setting the positionUsesAnchorPoint to false\n");
6950
6951   Actor actor = Actor::New();
6952   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6953   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
6954   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
6955   actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Degree(90.0f), Vector3::ZAXIS));
6956   actor.SetProperty(Actor::Property::SCALE, 2.0f);
6957   actor.SetProperty(Actor::Property::POSITION_USES_ANCHOR_POINT, false);
6958   application.GetScene().Add(actor);
6959
6960   application.SendNotification();
6961   application.Render();
6962
6963   tet_infoline("Check the world position is the same as it would be without a scale and rotation\n");
6964   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(50.0f, 50.0f, 0.0f), TEST_LOCATION);
6965
6966   tet_infoline("Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly");
6967   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
6968   application.SendNotification();
6969   application.Render();
6970   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(-100.0f, 100.0f, 0.0f), TEST_LOCATION);
6971
6972   tet_infoline("Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly");
6973   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
6974   application.SendNotification();
6975   application.Render();
6976   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(200.0f, 0.0f, 0.0f), TEST_LOCATION);
6977
6978   END_TEST;
6979 }
6980
6981 int utcDaliActorPositionUsesAnchorPointOnlyInheritPosition(void)
6982 {
6983   TestApplication application;
6984   tet_infoline("Check that if not inheriting scale and position, then the position is adjusted appropriately when setting the positionUsesAnchorPoint to false\n");
6985
6986   Actor parent = Actor::New();
6987
6988   application.GetScene().Add(parent);
6989   Vector2 stageSize(application.GetScene().GetSize());
6990
6991   Actor actor = Actor::New();
6992   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
6993   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
6994   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
6995   actor.SetProperty(Actor::Property::INHERIT_SCALE, false);
6996   actor.SetProperty(Actor::Property::INHERIT_ORIENTATION, false);
6997   actor.SetProperty(Actor::Property::POSITION_USES_ANCHOR_POINT, false);
6998   parent.Add(actor);
6999
7000   application.SendNotification();
7001   application.Render();
7002
7003   const Vector3 expectedWorldPosition(-stageSize.width * 0.5f + 50.0f, -stageSize.height * 0.5f + 50.0f, 0.0f);
7004
7005   tet_infoline("Check the world position is in the right place\n");
7006   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), expectedWorldPosition, TEST_LOCATION);
7007
7008   tet_infoline("Change the Anchor Point to TOP_LEFT and ensure world position hasn't changed");
7009   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
7010   application.SendNotification();
7011   application.Render();
7012   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), expectedWorldPosition, TEST_LOCATION);
7013
7014   tet_infoline("Change the Anchor Point to BOTTOM_RIGHT and ensure world position hasn't changed");
7015   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
7016   application.SendNotification();
7017   application.Render();
7018   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), expectedWorldPosition, TEST_LOCATION);
7019
7020   END_TEST;
7021 }
7022
7023 int utcDaliActorVisibilityChangeSignalSelf(void)
7024 {
7025   TestApplication application;
7026   tet_infoline("Check that the visibility change signal is called when the visibility changes for the actor itself");
7027
7028   Actor actor = Actor::New();
7029
7030   VisibilityChangedFunctorData data;
7031   DevelActor::VisibilityChangedSignal(actor).Connect(&application, VisibilityChangedFunctor(data));
7032
7033   actor.SetProperty(Actor::Property::VISIBLE, false);
7034
7035   data.Check(true /* called */, actor, false /* not visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION);
7036
7037   tet_infoline("Ensure functor is not called if we attempt to change the visibility to what it already is at");
7038   data.Reset();
7039
7040   actor.SetProperty(Actor::Property::VISIBLE, false);
7041   data.Check(false /* not called */, TEST_LOCATION);
7042
7043   tet_infoline("Change the visibility using properties, ensure called");
7044   data.Reset();
7045
7046   actor.SetProperty(Actor::Property::VISIBLE, true);
7047   data.Check(true /* called */, actor, true /* visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION);
7048
7049   tet_infoline("Set the visibility to current using properties, ensure not called");
7050   data.Reset();
7051
7052   actor.SetProperty(Actor::Property::VISIBLE, true);
7053   data.Check(false /* not called */, TEST_LOCATION);
7054
7055   END_TEST;
7056 }
7057
7058 int utcDaliActorVisibilityChangeSignalChildren(void)
7059 {
7060   TestApplication application;
7061   tet_infoline("Check that the visibility change signal is called for the children when the visibility changes for the parent");
7062
7063   Actor parent = Actor::New();
7064   Actor child  = Actor::New();
7065   parent.Add(child);
7066
7067   Actor grandChild = Actor::New();
7068   child.Add(grandChild);
7069
7070   VisibilityChangedFunctorData parentData;
7071   VisibilityChangedFunctorData childData;
7072   VisibilityChangedFunctorData grandChildData;
7073
7074   tet_infoline("Only connect the child and grandchild, ensure they are called and not the parent");
7075   DevelActor::VisibilityChangedSignal(child).Connect(&application, VisibilityChangedFunctor(childData));
7076   DevelActor::VisibilityChangedSignal(grandChild).Connect(&application, VisibilityChangedFunctor(grandChildData));
7077
7078   parent.SetProperty(Actor::Property::VISIBLE, false);
7079   parentData.Check(false /* not called */, TEST_LOCATION);
7080   childData.Check(true /* called */, child, false /* not visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION);
7081   grandChildData.Check(true /* called */, grandChild, false /* not visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION);
7082
7083   tet_infoline("Connect to the parent's signal as well and ensure all three are called");
7084   parentData.Reset();
7085   childData.Reset();
7086   grandChildData.Reset();
7087
7088   DevelActor::VisibilityChangedSignal(parent).Connect(&application, VisibilityChangedFunctor(parentData));
7089
7090   parent.SetProperty(Actor::Property::VISIBLE, true);
7091   parentData.Check(true /* called */, parent, true /* visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION);
7092   childData.Check(true /* called */, child, true /* visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION);
7093   grandChildData.Check(true /* called */, grandChild, true /* visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION);
7094
7095   tet_infoline("Ensure none of the functors are called if we attempt to change the visibility to what it already is at");
7096   parentData.Reset();
7097   childData.Reset();
7098   grandChildData.Reset();
7099
7100   parent.SetProperty(Actor::Property::VISIBLE, true);
7101   parentData.Check(false /* not called */, TEST_LOCATION);
7102   childData.Check(false /* not called */, TEST_LOCATION);
7103   grandChildData.Check(false /* not called */, TEST_LOCATION);
7104
7105   END_TEST;
7106 }
7107
7108 int utcDaliActorVisibilityChangeSignalAfterAnimation(void)
7109 {
7110   TestApplication application;
7111   tet_infoline("Check that the visibility change signal is emitted when the visibility changes when an animation starts");
7112
7113   Actor actor = Actor::New();
7114   application.GetScene().Add(actor);
7115
7116   application.SendNotification();
7117   application.Render();
7118
7119   VisibilityChangedFunctorData data;
7120   DevelActor::VisibilityChangedSignal(actor).Connect(&application, VisibilityChangedFunctor(data));
7121
7122   Animation animation = Animation::New(1.0f);
7123   animation.AnimateTo(Property(actor, Actor::Property::VISIBLE), false);
7124
7125   data.Check(false, TEST_LOCATION);
7126   DALI_TEST_EQUALS(actor.GetProperty<bool>(Actor::Property::VISIBLE), true, TEST_LOCATION);
7127   DALI_TEST_EQUALS(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE), true, TEST_LOCATION);
7128
7129   tet_infoline("Play the animation and check the property value");
7130   animation.Play();
7131
7132   data.Check(true /* called */, actor, false /* not visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION);
7133   DALI_TEST_EQUALS(actor.GetProperty<bool>(Actor::Property::VISIBLE), false, TEST_LOCATION);
7134
7135   tet_infoline("Animation not currently finished, so the current visibility should still be true");
7136   DALI_TEST_EQUALS(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE), true, TEST_LOCATION);
7137
7138   application.SendNotification();
7139   application.Render(1100); // After the animation
7140
7141   DALI_TEST_EQUALS(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE), false, TEST_LOCATION);
7142
7143   END_TEST;
7144 }
7145
7146 int utcDaliActorVisibilityChangeSignalByName(void)
7147 {
7148   TestApplication application;
7149   tet_infoline("Check that the visibility change signal is called when the visibility changes for the actor itself");
7150
7151   Actor actor = Actor::New();
7152
7153   bool signalCalled = false;
7154   actor.ConnectSignal(&application, "visibilityChanged", VisibilityChangedVoidFunctor(signalCalled));
7155   DALI_TEST_EQUALS(signalCalled, false, TEST_LOCATION);
7156   actor.SetProperty(Actor::Property::VISIBLE, false);
7157   DALI_TEST_EQUALS(signalCalled, true, TEST_LOCATION);
7158
7159   tet_infoline("Ensure functor is not called if we attempt to change the visibility to what it already is at");
7160   signalCalled = false;
7161   actor.SetProperty(Actor::Property::VISIBLE, false);
7162   DALI_TEST_EQUALS(signalCalled, false, TEST_LOCATION);
7163
7164   tet_infoline("Change the visibility using properties, ensure called");
7165   actor.SetProperty(Actor::Property::VISIBLE, true);
7166   DALI_TEST_EQUALS(signalCalled, true, TEST_LOCATION);
7167
7168   tet_infoline("Set the visibility to current using properties, ensure not called");
7169   signalCalled = false;
7170
7171   actor.SetProperty(Actor::Property::VISIBLE, true);
7172   DALI_TEST_EQUALS(signalCalled, false, TEST_LOCATION);
7173
7174   END_TEST;
7175 }
7176
7177 static void LayoutDirectionChanged(Actor actor, LayoutDirection::Type type)
7178 {
7179   gLayoutDirectionType = type;
7180 }
7181
7182 int UtcDaliActorLayoutDirectionProperty(void)
7183 {
7184   TestApplication application;
7185   tet_infoline("Check layout direction property");
7186
7187   Actor actor0 = Actor::New();
7188   DALI_TEST_EQUALS(actor0.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7189   application.GetScene().Add(actor0);
7190
7191   application.SendNotification();
7192   application.Render();
7193
7194   Actor actor1 = Actor::New();
7195   DALI_TEST_EQUALS(actor1.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7196   Actor actor2 = Actor::New();
7197   DALI_TEST_EQUALS(actor2.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7198   Actor actor3 = Actor::New();
7199   DALI_TEST_EQUALS(actor3.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7200   Actor actor4 = Actor::New();
7201   DALI_TEST_EQUALS(actor4.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7202   Actor actor5 = Actor::New();
7203   DALI_TEST_EQUALS(actor5.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7204   Actor actor6 = Actor::New();
7205   DALI_TEST_EQUALS(actor6.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7206   Actor actor7 = Actor::New();
7207   DALI_TEST_EQUALS(actor7.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7208   Actor actor8 = Actor::New();
7209   DALI_TEST_EQUALS(actor8.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7210   Actor actor9 = Actor::New();
7211   DALI_TEST_EQUALS(actor9.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7212
7213   actor1.Add(actor2);
7214   gLayoutDirectionType = LayoutDirection::LEFT_TO_RIGHT;
7215   actor2.LayoutDirectionChangedSignal().Connect(LayoutDirectionChanged);
7216
7217   DALI_TEST_EQUALS(actor1.GetProperty<bool>(Actor::Property::INHERIT_LAYOUT_DIRECTION), true, TEST_LOCATION);
7218   actor1.SetProperty(Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT);
7219   DALI_TEST_EQUALS(actor1.GetProperty<bool>(Actor::Property::INHERIT_LAYOUT_DIRECTION), false, TEST_LOCATION);
7220
7221   DALI_TEST_EQUALS(actor1.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
7222   DALI_TEST_EQUALS(actor2.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
7223   DALI_TEST_EQUALS(gLayoutDirectionType, LayoutDirection::RIGHT_TO_LEFT, TEST_LOCATION);
7224
7225   actor1.SetProperty(Actor::Property::INHERIT_LAYOUT_DIRECTION, true);
7226   actor0.Add(actor1);
7227   DALI_TEST_EQUALS(actor1.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7228   DALI_TEST_EQUALS(actor2.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7229
7230   application.GetScene().Add(actor3);
7231   actor3.Add(actor4);
7232   actor4.Add(actor5);
7233   actor5.Add(actor6);
7234   actor5.Add(actor7);
7235   actor7.Add(actor8);
7236   actor8.Add(actor9);
7237   actor3.SetProperty(Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT");
7238   actor5.SetProperty(Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT);
7239
7240   DALI_TEST_EQUALS(actor8.GetProperty<bool>(Actor::Property::INHERIT_LAYOUT_DIRECTION), true, TEST_LOCATION);
7241   actor8.SetProperty(Actor::Property::INHERIT_LAYOUT_DIRECTION, false);
7242   DALI_TEST_EQUALS(actor8.GetProperty<bool>(Actor::Property::INHERIT_LAYOUT_DIRECTION), false, TEST_LOCATION);
7243
7244   actor7.SetProperty(Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT");
7245
7246   DALI_TEST_EQUALS(actor3.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
7247   DALI_TEST_EQUALS(actor4.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
7248   DALI_TEST_EQUALS(actor5.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7249   DALI_TEST_EQUALS(actor6.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7250   DALI_TEST_EQUALS(actor7.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
7251   DALI_TEST_EQUALS(actor8.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7252   DALI_TEST_EQUALS(actor9.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7253
7254   actor8.SetProperty(Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT");
7255   DALI_TEST_EQUALS(actor8.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
7256   DALI_TEST_EQUALS(actor9.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
7257
7258   actor7.SetProperty(Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT);
7259   DALI_TEST_EQUALS(actor7.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7260   DALI_TEST_EQUALS(actor8.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
7261   DALI_TEST_EQUALS(actor9.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
7262
7263   actor8.SetProperty(Actor::Property::INHERIT_LAYOUT_DIRECTION, true);
7264   DALI_TEST_EQUALS(actor8.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7265   DALI_TEST_EQUALS(actor9.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7266
7267   END_TEST;
7268 }
7269
7270 struct LayoutDirectionFunctor
7271 {
7272   LayoutDirectionFunctor(bool& signalCalled)
7273   : mSignalCalled(signalCalled)
7274   {
7275   }
7276
7277   LayoutDirectionFunctor(const LayoutDirectionFunctor& rhs)
7278   : mSignalCalled(rhs.mSignalCalled)
7279   {
7280   }
7281
7282   void operator()()
7283   {
7284     mSignalCalled = true;
7285   }
7286
7287   bool& mSignalCalled;
7288 };
7289
7290 int UtcDaliActorLayoutDirectionSignal(void)
7291 {
7292   TestApplication application;
7293   tet_infoline("Check changing layout direction property sends a signal");
7294
7295   Actor actor = Actor::New();
7296   DALI_TEST_EQUALS(actor.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
7297   application.GetScene().Add(actor);
7298   bool                   signalCalled = false;
7299   LayoutDirectionFunctor layoutDirectionFunctor(signalCalled);
7300
7301   actor.ConnectSignal(&application, "layoutDirectionChanged", layoutDirectionFunctor);
7302   DALI_TEST_EQUALS(signalCalled, false, TEST_LOCATION);
7303
7304   // Test that writing the same value doesn't send a signal
7305   actor.SetProperty(Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT);
7306   DALI_TEST_EQUALS(signalCalled, false, TEST_LOCATION);
7307
7308   // Test that writing a different value sends the signal
7309   signalCalled = false;
7310   actor.SetProperty(Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT);
7311   DALI_TEST_EQUALS(signalCalled, true, TEST_LOCATION);
7312
7313   signalCalled = false;
7314   actor.SetProperty(Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT);
7315   DALI_TEST_EQUALS(signalCalled, false, TEST_LOCATION);
7316
7317   END_TEST;
7318 }
7319
7320 struct ChildAddedSignalCheck
7321 {
7322   ChildAddedSignalCheck(bool& signalReceived, Actor& childHandle)
7323   : mSignalReceived(signalReceived),
7324     mChildHandle(childHandle)
7325   {
7326   }
7327
7328   void operator()(Actor childHandle)
7329   {
7330     mSignalReceived = true;
7331     mChildHandle    = childHandle;
7332   }
7333   void operator()()
7334   {
7335     mSignalReceived = true;
7336     mChildHandle    = Actor();
7337   }
7338
7339   bool&  mSignalReceived;
7340   Actor& mChildHandle;
7341 };
7342
7343 int UtcDaliChildAddedSignalP1(void)
7344 {
7345   TestApplication application;
7346   auto            stage = application.GetScene();
7347
7348   bool  signalReceived = false;
7349   Actor childActor;
7350
7351   ChildAddedSignalCheck signal(signalReceived, childActor);
7352   DevelActor::ChildAddedSignal(stage.GetRootLayer()).Connect(&application, signal);
7353   DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
7354
7355   auto actorA = Actor::New();
7356   stage.Add(actorA);
7357   DALI_TEST_EQUALS(signalReceived, true, TEST_LOCATION);
7358   DALI_TEST_EQUALS(childActor, actorA, TEST_LOCATION);
7359   signalReceived = false;
7360
7361   auto actorB = Actor::New();
7362   stage.Add(actorB);
7363   DALI_TEST_EQUALS(signalReceived, true, TEST_LOCATION);
7364   DALI_TEST_EQUALS(childActor, actorB, TEST_LOCATION);
7365
7366   END_TEST;
7367 }
7368
7369 int UtcDaliChildAddedSignalP2(void)
7370 {
7371   TestApplication application;
7372   auto            stage = application.GetScene();
7373
7374   bool  signalReceived = false;
7375   Actor childActor;
7376
7377   ChildAddedSignalCheck signal(signalReceived, childActor);
7378   tet_infoline("Connect to childAdded signal by name");
7379
7380   stage.GetRootLayer().ConnectSignal(&application, "childAdded", signal);
7381   DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
7382
7383   auto actorA = Actor::New();
7384   stage.Add(actorA);
7385   DALI_TEST_EQUALS(signalReceived, true, TEST_LOCATION);
7386
7387   // Can't test which actor was added; signal signature is void() when connecting via name.
7388   signalReceived = false;
7389
7390   auto actorB = Actor::New();
7391   stage.Add(actorB);
7392   DALI_TEST_EQUALS(signalReceived, true, TEST_LOCATION);
7393
7394   END_TEST;
7395 }
7396
7397 int UtcDaliChildAddedSignalN(void)
7398 {
7399   TestApplication application;
7400   auto            stage = application.GetScene();
7401
7402   bool  signalReceived = false;
7403   Actor childActor;
7404
7405   ChildAddedSignalCheck signal(signalReceived, childActor);
7406   DevelActor::ChildAddedSignal(stage.GetRootLayer()).Connect(&application, signal);
7407   DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
7408
7409   auto actorA = Actor::New();
7410   stage.Add(actorA);
7411   DALI_TEST_EQUALS(signalReceived, true, TEST_LOCATION);
7412   DALI_TEST_EQUALS(childActor, actorA, TEST_LOCATION);
7413   signalReceived = false;
7414
7415   auto actorB = Actor::New();
7416   actorA.Add(actorB);
7417   DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
7418   END_TEST;
7419 }
7420
7421 struct ChildRemovedSignalCheck
7422 {
7423   ChildRemovedSignalCheck(bool& signalReceived, Actor& childHandle)
7424   : mSignalReceived(signalReceived),
7425     mChildHandle(childHandle)
7426   {
7427   }
7428
7429   void operator()(Actor childHandle)
7430   {
7431     mSignalReceived = true;
7432     mChildHandle    = childHandle;
7433   }
7434
7435   void operator()()
7436   {
7437     mSignalReceived = true;
7438   }
7439
7440   bool&  mSignalReceived;
7441   Actor& mChildHandle;
7442 };
7443
7444 int UtcDaliChildRemovedSignalP1(void)
7445 {
7446   TestApplication application;
7447   auto            stage = application.GetScene();
7448
7449   bool  signalReceived = false;
7450   Actor childActor;
7451
7452   ChildRemovedSignalCheck signal(signalReceived, childActor);
7453   DevelActor::ChildRemovedSignal(stage.GetRootLayer()).Connect(&application, signal);
7454   DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
7455
7456   auto actorA = Actor::New();
7457   stage.Add(actorA);
7458   DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
7459   DALI_TEST_CHECK(!childActor);
7460
7461   stage.Remove(actorA);
7462   DALI_TEST_EQUALS(childActor, actorA, TEST_LOCATION);
7463   DALI_TEST_EQUALS(signalReceived, true, TEST_LOCATION);
7464
7465   signalReceived = false;
7466   auto actorB    = Actor::New();
7467   stage.Add(actorB);
7468   DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
7469
7470   stage.Remove(actorB);
7471   DALI_TEST_EQUALS(signalReceived, true, TEST_LOCATION);
7472   DALI_TEST_EQUALS(childActor, actorB, TEST_LOCATION);
7473
7474   END_TEST;
7475 }
7476
7477 int UtcDaliChildRemovedSignalP2(void)
7478 {
7479   TestApplication application;
7480   auto            stage = application.GetScene();
7481
7482   bool  signalReceived = false;
7483   Actor childActor;
7484
7485   ChildAddedSignalCheck signal(signalReceived, childActor);
7486   tet_infoline("Connect to childRemoved signal by name");
7487
7488   stage.GetRootLayer().ConnectSignal(&application, "childRemoved", signal);
7489   DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
7490
7491   auto actorA = Actor::New();
7492   stage.Add(actorA);
7493   DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
7494
7495   stage.Remove(actorA);
7496   DALI_TEST_EQUALS(signalReceived, true, TEST_LOCATION);
7497
7498   signalReceived = false;
7499   auto actorB    = Actor::New();
7500   stage.Add(actorB);
7501   DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
7502
7503   stage.Remove(actorB);
7504   DALI_TEST_EQUALS(signalReceived, true, TEST_LOCATION);
7505
7506   END_TEST;
7507 }
7508
7509 int UtcDaliChildRemovedSignalN(void)
7510 {
7511   TestApplication application;
7512   auto            stage = application.GetScene();
7513
7514   bool  signalReceived = false;
7515   Actor childActor;
7516
7517   ChildRemovedSignalCheck signal(signalReceived, childActor);
7518   DevelActor::ChildRemovedSignal(stage.GetRootLayer()).Connect(&application, signal);
7519   DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
7520
7521   auto actorA = Actor::New();
7522   stage.Add(actorA);
7523
7524   auto actorB = Actor::New();
7525   actorA.Add(actorB);
7526
7527   DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
7528   DALI_TEST_CHECK(!childActor);
7529
7530   actorA.Remove(actorB);
7531   DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
7532   END_TEST;
7533 }
7534
7535 int UtcDaliChildMovedSignalP(void)
7536 {
7537   TestApplication application;
7538   auto            stage = application.GetScene();
7539
7540   bool  addedASignalReceived   = false;
7541   bool  removedASignalReceived = false;
7542   bool  addedBSignalReceived   = false;
7543   bool  removedBSignalReceived = false;
7544   Actor childActor;
7545
7546   auto actorA = Actor::New();
7547   auto actorB = Actor::New();
7548   stage.Add(actorA);
7549   stage.Add(actorB);
7550
7551   ChildAddedSignalCheck   addedSignalA(addedASignalReceived, childActor);
7552   ChildRemovedSignalCheck removedSignalA(removedASignalReceived, childActor);
7553   ChildAddedSignalCheck   addedSignalB(addedBSignalReceived, childActor);
7554   ChildRemovedSignalCheck removedSignalB(removedBSignalReceived, childActor);
7555
7556   DevelActor::ChildAddedSignal(actorA).Connect(&application, addedSignalA);
7557   DevelActor::ChildRemovedSignal(actorA).Connect(&application, removedSignalA);
7558   DevelActor::ChildAddedSignal(actorB).Connect(&application, addedSignalB);
7559   DevelActor::ChildRemovedSignal(actorB).Connect(&application, removedSignalB);
7560
7561   DALI_TEST_EQUALS(addedASignalReceived, false, TEST_LOCATION);
7562   DALI_TEST_EQUALS(removedASignalReceived, false, TEST_LOCATION);
7563   DALI_TEST_EQUALS(addedBSignalReceived, false, TEST_LOCATION);
7564   DALI_TEST_EQUALS(removedBSignalReceived, false, TEST_LOCATION);
7565
7566   // Create a child of A
7567
7568   auto child = Actor::New();
7569   actorA.Add(child);
7570
7571   DALI_TEST_EQUALS(addedASignalReceived, true, TEST_LOCATION);
7572   DALI_TEST_EQUALS(removedASignalReceived, false, TEST_LOCATION);
7573   DALI_TEST_EQUALS(addedBSignalReceived, false, TEST_LOCATION);
7574   DALI_TEST_EQUALS(removedBSignalReceived, false, TEST_LOCATION);
7575   DALI_TEST_EQUALS(childActor, child, TEST_LOCATION);
7576
7577   // Move child to B:
7578   addedASignalReceived   = false;
7579   addedBSignalReceived   = false;
7580   removedASignalReceived = false;
7581   removedBSignalReceived = false;
7582
7583   actorB.Add(child); // Expect this child to be re-parented
7584   DALI_TEST_EQUALS(addedASignalReceived, false, TEST_LOCATION);
7585   DALI_TEST_EQUALS(removedASignalReceived, true, TEST_LOCATION);
7586   DALI_TEST_EQUALS(addedBSignalReceived, true, TEST_LOCATION);
7587   DALI_TEST_EQUALS(removedBSignalReceived, false, TEST_LOCATION);
7588
7589   // Move child back to A:
7590   addedASignalReceived   = false;
7591   addedBSignalReceived   = false;
7592   removedASignalReceived = false;
7593   removedBSignalReceived = false;
7594
7595   actorA.Add(child); // Expect this child to be re-parented
7596   DALI_TEST_EQUALS(addedASignalReceived, true, TEST_LOCATION);
7597   DALI_TEST_EQUALS(removedASignalReceived, false, TEST_LOCATION);
7598   DALI_TEST_EQUALS(addedBSignalReceived, false, TEST_LOCATION);
7599   DALI_TEST_EQUALS(removedBSignalReceived, true, TEST_LOCATION);
7600
7601   END_TEST;
7602 }
7603
7604 int utcDaliActorCulled(void)
7605 {
7606   TestApplication application;
7607   auto            stage = application.GetScene();
7608
7609   tet_infoline("Check that the actor is culled if the actor is out of the screen");
7610
7611   Actor actor = Actor::New();
7612   actor.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
7613
7614   Geometry geometry = CreateQuadGeometry();
7615   Shader   shader   = CreateShader();
7616   Renderer renderer = Renderer::New(geometry, shader);
7617   actor.AddRenderer(renderer);
7618
7619   stage.Add(actor);
7620
7621   application.SendNotification();
7622   application.Render(0);
7623
7624   DALI_TEST_EQUALS(actor.GetProperty<bool>(Actor::Property::CULLED), false, TEST_LOCATION);
7625
7626   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::CULLED, LessThanCondition(0.5f));
7627   notification.SetNotifyMode(PropertyNotification::NOTIFY_ON_CHANGED);
7628
7629   // Connect NotifySignal
7630   bool                              propertyNotificationSignal(false);
7631   PropertyNotification              source;
7632   CulledPropertyNotificationFunctor f(propertyNotificationSignal, source);
7633   notification.NotifySignal().Connect(&application, f);
7634
7635   actor.SetProperty(Actor::Property::POSITION, Vector2(1000.0f, 1000.0f));
7636
7637   application.SendNotification();
7638   application.Render();
7639
7640   application.SendNotification();
7641
7642   DALI_TEST_EQUALS(actor.GetProperty<bool>(Actor::Property::CULLED), true, TEST_LOCATION);
7643
7644   DALI_TEST_EQUALS(propertyNotificationSignal, true, TEST_LOCATION);
7645   DALI_TEST_EQUALS(source.GetTargetProperty(), static_cast<int>(Actor::Property::CULLED), TEST_LOCATION);
7646   DALI_TEST_EQUALS(source.GetTarget().GetProperty<bool>(source.GetTargetProperty()), true, TEST_LOCATION);
7647
7648   END_TEST;
7649 }
7650
7651 int utcDaliEnsureRenderWhenRemovingLastRenderableActor(void)
7652 {
7653   TestApplication application;
7654   auto            stage = application.GetScene();
7655
7656   tet_infoline("Ensure we clear the screen when the last actor is removed");
7657
7658   Actor actor = CreateRenderableActor();
7659   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
7660   stage.Add(actor);
7661
7662   application.SendNotification();
7663   application.Render();
7664
7665   auto&      glAbstraction    = application.GetGlAbstraction();
7666   const auto clearCountBefore = glAbstraction.GetClearCountCalled();
7667
7668   actor.Unparent();
7669
7670   application.SendNotification();
7671   application.Render();
7672
7673   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION);
7674
7675   END_TEST;
7676 }
7677
7678 int utcDaliEnsureRenderWhenMakingLastActorInvisible(void)
7679 {
7680   TestApplication application;
7681   auto            stage = application.GetScene();
7682
7683   tet_infoline("Ensure we clear the screen when the last actor is made invisible");
7684
7685   Actor actor = CreateRenderableActor();
7686   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
7687   stage.Add(actor);
7688
7689   application.SendNotification();
7690   application.Render();
7691
7692   auto&      glAbstraction    = application.GetGlAbstraction();
7693   const auto clearCountBefore = glAbstraction.GetClearCountCalled();
7694
7695   actor.SetProperty(Actor::Property::VISIBLE, false);
7696
7697   application.SendNotification();
7698   application.Render();
7699
7700   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION);
7701
7702   END_TEST;
7703 }
7704
7705 int utcDaliActorGetSizeAfterAnimation(void)
7706 {
7707   TestApplication application;
7708   tet_infoline("Check the actor size before / after an animation is finished");
7709
7710   Vector3 actorSize(100.0f, 100.0f, 0.0f);
7711
7712   Actor actor = Actor::New();
7713   actor.SetProperty(Actor::Property::SIZE, actorSize);
7714   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
7715   application.GetScene().Add(actor);
7716
7717   // Size should be updated without rendering.
7718   Vector3 size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
7719   DALI_TEST_EQUALS(size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7720
7721   application.SendNotification();
7722   application.Render();
7723
7724   // Size and current size should be updated.
7725   size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
7726   DALI_TEST_EQUALS(size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7727   DALI_TEST_EQUALS(actorSize.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
7728   DALI_TEST_EQUALS(actorSize.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
7729   DALI_TEST_EQUALS(actorSize.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
7730
7731   Vector3 currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
7732   DALI_TEST_EQUALS(currentSize, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7733   DALI_TEST_EQUALS(actorSize.width, actor.GetCurrentProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
7734   DALI_TEST_EQUALS(actorSize.height, actor.GetCurrentProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
7735   DALI_TEST_EQUALS(actorSize.depth, actor.GetCurrentProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
7736
7737   // Set size again
7738   actorSize = Vector3(200.0f, 200.0f, 0.0f);
7739   actor.SetProperty(Actor::Property::SIZE, actorSize);
7740
7741   size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
7742   DALI_TEST_EQUALS(size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7743
7744   Vector3 targetValue(10.0f, 20.0f, 0.0f);
7745
7746   Animation animation = Animation::New(1.0f);
7747   animation.AnimateTo(Property(actor, Actor::Property::SIZE), targetValue);
7748   animation.Play();
7749
7750   // Size should be updated without rendering.
7751   size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
7752   DALI_TEST_EQUALS(size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7753
7754   application.SendNotification();
7755   application.Render(1100); // After the animation
7756
7757   size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
7758   DALI_TEST_EQUALS(size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7759   DALI_TEST_EQUALS(targetValue.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
7760   DALI_TEST_EQUALS(targetValue.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
7761   DALI_TEST_EQUALS(targetValue.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
7762
7763   currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
7764   DALI_TEST_EQUALS(currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7765   DALI_TEST_EQUALS(targetValue.width, actor.GetCurrentProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
7766   DALI_TEST_EQUALS(targetValue.height, actor.GetCurrentProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
7767   DALI_TEST_EQUALS(targetValue.depth, actor.GetCurrentProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
7768
7769   targetValue.width = 50.0f;
7770
7771   animation.Clear();
7772   animation.AnimateTo(Property(actor, Actor::Property::SIZE_WIDTH), targetValue.width);
7773   animation.Play();
7774
7775   application.SendNotification();
7776   application.Render(1100); // After the animation
7777
7778   size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
7779   DALI_TEST_EQUALS(size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7780   DALI_TEST_EQUALS(targetValue.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
7781   DALI_TEST_EQUALS(targetValue.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
7782   DALI_TEST_EQUALS(targetValue.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
7783
7784   currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
7785   DALI_TEST_EQUALS(currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7786   DALI_TEST_EQUALS(targetValue.width, actor.GetCurrentProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
7787   DALI_TEST_EQUALS(targetValue.height, actor.GetCurrentProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
7788   DALI_TEST_EQUALS(targetValue.depth, actor.GetCurrentProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
7789
7790   targetValue.height = 70.0f;
7791
7792   animation.Clear();
7793   animation.AnimateTo(Property(actor, Actor::Property::SIZE_HEIGHT), targetValue.height);
7794   animation.Play();
7795
7796   application.SendNotification();
7797   application.Render(1100); // After the animation
7798
7799   size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
7800   DALI_TEST_EQUALS(size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7801   DALI_TEST_EQUALS(targetValue.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
7802   DALI_TEST_EQUALS(targetValue.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
7803   DALI_TEST_EQUALS(targetValue.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
7804
7805   currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
7806   DALI_TEST_EQUALS(currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7807   DALI_TEST_EQUALS(targetValue.width, actor.GetCurrentProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
7808   DALI_TEST_EQUALS(targetValue.height, actor.GetCurrentProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
7809   DALI_TEST_EQUALS(targetValue.depth, actor.GetCurrentProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
7810
7811   Vector3 offset(10.0f, 20.0f, 0.0f);
7812
7813   animation.Clear();
7814   animation.AnimateBy(Property(actor, Actor::Property::SIZE), offset);
7815   animation.Play();
7816
7817   application.SendNotification();
7818   application.Render(1100); // After the animation
7819
7820   targetValue += offset;
7821
7822   size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
7823   DALI_TEST_EQUALS(size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7824   DALI_TEST_EQUALS(targetValue.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
7825   DALI_TEST_EQUALS(targetValue.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
7826   DALI_TEST_EQUALS(targetValue.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
7827
7828   currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
7829   DALI_TEST_EQUALS(currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7830   DALI_TEST_EQUALS(targetValue.width, actor.GetCurrentProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
7831   DALI_TEST_EQUALS(targetValue.height, actor.GetCurrentProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
7832   DALI_TEST_EQUALS(targetValue.depth, actor.GetCurrentProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
7833
7834   offset.width = 20.0f;
7835
7836   animation.Clear();
7837   animation.AnimateBy(Property(actor, Actor::Property::SIZE_WIDTH), offset.width);
7838   animation.Play();
7839
7840   application.SendNotification();
7841   application.Render(1100); // After the animation
7842
7843   targetValue.width += offset.width;
7844
7845   size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
7846   DALI_TEST_EQUALS(size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7847   DALI_TEST_EQUALS(targetValue.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
7848   DALI_TEST_EQUALS(targetValue.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
7849   DALI_TEST_EQUALS(targetValue.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
7850
7851   currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
7852   DALI_TEST_EQUALS(currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7853   DALI_TEST_EQUALS(targetValue.width, actor.GetCurrentProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
7854   DALI_TEST_EQUALS(targetValue.height, actor.GetCurrentProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
7855   DALI_TEST_EQUALS(targetValue.depth, actor.GetCurrentProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
7856
7857   offset.height = 10.0f;
7858
7859   animation.Clear();
7860   animation.AnimateBy(Property(actor, Actor::Property::SIZE_HEIGHT), offset.height);
7861   animation.Play();
7862
7863   application.SendNotification();
7864   application.Render(1100); // After the animation
7865
7866   targetValue.height += offset.height;
7867
7868   size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
7869   DALI_TEST_EQUALS(size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7870   DALI_TEST_EQUALS(targetValue.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
7871   DALI_TEST_EQUALS(targetValue.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
7872   DALI_TEST_EQUALS(targetValue.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
7873
7874   currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
7875   DALI_TEST_EQUALS(currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7876   DALI_TEST_EQUALS(targetValue.width, actor.GetCurrentProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
7877   DALI_TEST_EQUALS(targetValue.height, actor.GetCurrentProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
7878   DALI_TEST_EQUALS(targetValue.depth, actor.GetCurrentProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
7879
7880   // Set size again
7881   actorSize = Vector3(300.0f, 300.0f, 0.0f);
7882
7883   actor.SetProperty(Actor::Property::SIZE, actorSize);
7884
7885   size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
7886   DALI_TEST_EQUALS(size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7887
7888   currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
7889   DALI_TEST_EQUALS(currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7890
7891   application.SendNotification();
7892   application.Render();
7893
7894   size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
7895   DALI_TEST_EQUALS(size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7896
7897   currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
7898   DALI_TEST_EQUALS(currentSize, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
7899
7900   END_TEST;
7901 }
7902
7903 int utcDaliActorPartialUpdate(void)
7904 {
7905   TestApplication application(
7906     TestApplication::DEFAULT_SURFACE_WIDTH,
7907     TestApplication::DEFAULT_SURFACE_HEIGHT,
7908     TestApplication::DEFAULT_HORIZONTAL_DPI,
7909     TestApplication::DEFAULT_VERTICAL_DPI,
7910     true,
7911     true);
7912
7913   tet_infoline("Check the damaged area");
7914
7915   const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
7916
7917   std::vector<Rect<int>> damagedRects;
7918   Rect<int>              clippingRect;
7919   application.SendNotification();
7920   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
7921
7922   // First render pass, nothing to render, adaptor would just do swap buffer.
7923   DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
7924   application.RenderWithPartialUpdate(damagedRects, clippingRect);
7925
7926   Actor actor = CreateRenderableActor();
7927   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
7928   actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
7929   actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
7930   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
7931   application.GetScene().Add(actor);
7932
7933   application.SendNotification();
7934
7935   // 1. Actor added, damaged rect is added size of actor
7936   damagedRects.clear();
7937   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
7938   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
7939
7940   // Aligned by 16
7941   clippingRect = Rect<int>(16, 768, 32, 32); // in screen coordinates, includes 3 last frames updates
7942   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
7943   application.RenderWithPartialUpdate(damagedRects, clippingRect);
7944   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
7945   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
7946   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
7947   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
7948
7949   // 2. Set new size
7950   actor.SetProperty(Actor::Property::SIZE, Vector3(32.0f, 32.0f, 0));
7951   application.SendNotification();
7952
7953   damagedRects.clear();
7954   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
7955   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
7956
7957   // Aligned by 16
7958   clippingRect = Rect<int>(16, 752, 48, 48); // in screen coordinates, includes 3 last frames updates
7959   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
7960   application.RenderWithPartialUpdate(damagedRects, clippingRect);
7961   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
7962   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
7963   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
7964   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
7965
7966   // 3. Set new position
7967   actor.SetProperty(Actor::Property::POSITION, Vector3(32.0f, 32.0f, 0));
7968   application.SendNotification();
7969
7970   damagedRects.clear();
7971   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
7972   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
7973
7974   // Aligned by 16
7975   clippingRect = Rect<int>(16, 736, 64, 64); // in screen coordinates, includes 3 last frames updates
7976   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
7977   application.RenderWithPartialUpdate(damagedRects, clippingRect);
7978   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
7979   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
7980   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
7981   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
7982
7983   application.GetScene().Remove(actor);
7984   application.SendNotification();
7985
7986   // Actor removed, last 3 dirty rects are reported. Adaptor would merge them together.
7987   damagedRects.clear();
7988   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
7989   DALI_TEST_EQUALS(damagedRects.size(), 3, TEST_LOCATION);
7990
7991   clippingRect = damagedRects[0];
7992   clippingRect.Merge(damagedRects[1]);
7993   clippingRect.Merge(damagedRects[2]);
7994
7995   DALI_TEST_EQUALS(clippingRect.IsEmpty(), false, TEST_LOCATION);
7996   DALI_TEST_EQUALS(clippingRect.IsValid(), true, TEST_LOCATION);
7997   DALI_TEST_EQUALS<Rect<int>>(clippingRect, Rect<int>(16, 736, 64, 64), TEST_LOCATION);
7998
7999   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8000   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
8001   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
8002   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
8003   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
8004
8005   END_TEST;
8006 }
8007
8008 int utcDaliActorPartialUpdateSetColor(void)
8009 {
8010   TestApplication application(
8011     TestApplication::DEFAULT_SURFACE_WIDTH,
8012     TestApplication::DEFAULT_SURFACE_HEIGHT,
8013     TestApplication::DEFAULT_HORIZONTAL_DPI,
8014     TestApplication::DEFAULT_VERTICAL_DPI,
8015     true,
8016     true);
8017
8018   tet_infoline("Check uniform update");
8019
8020   const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
8021
8022   std::vector<Rect<int>> damagedRects;
8023   Rect<int>              clippingRect;
8024   application.SendNotification();
8025   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8026
8027   // First render pass, nothing to render, adaptor would just do swap buffer.
8028   DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
8029   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8030
8031   Actor actor = CreateRenderableActor();
8032   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
8033   actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
8034   actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
8035   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
8036   application.GetScene().Add(actor);
8037
8038   application.SendNotification();
8039
8040   // 1. Actor added, damaged rect is added size of actor
8041   damagedRects.clear();
8042   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8043   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
8044
8045   // Aligned by 16
8046   clippingRect = Rect<int>(16, 768, 32, 32); // in screen coordinates, includes 3 last frames updates
8047   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
8048   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8049   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
8050   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
8051   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
8052   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
8053
8054   damagedRects.clear();
8055   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8056
8057   damagedRects.clear();
8058   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8059
8060   // 2. Set new color
8061   actor.SetProperty(Actor::Property::COLOR, Vector3(1.0f, 0.0f, 0.0f));
8062   application.SendNotification();
8063
8064   damagedRects.clear();
8065   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8066   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
8067
8068   // Aligned by 16
8069   clippingRect = Rect<int>(16, 768, 32, 32); // in screen coordinates, includes 3 last frames updates
8070   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
8071   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8072   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
8073   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
8074   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
8075   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
8076
8077   END_TEST;
8078 }
8079
8080 const std::string SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME("uLightCameraProjectionMatrix");
8081 const std::string SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME("uLightCameraViewMatrix");
8082 const std::string SHADER_SHADOW_COLOR_PROPERTY_NAME("uShadowColor");
8083 const char* const RENDER_SHADOW_VERTEX_SOURCE =
8084   " uniform mediump mat4 uLightCameraProjectionMatrix;\n"
8085   " uniform mediump mat4 uLightCameraViewMatrix;\n"
8086   "\n"
8087   "void main()\n"
8088   "{\n"
8089   "  gl_Position = uProjection * uModelView * vec4(aPosition,1.0);\n"
8090   "  vec4 textureCoords = uLightCameraProjectionMatrix * uLightCameraViewMatrix * uModelMatrix  * vec4(aPosition,1.0);\n"
8091   "  vTexCoord = 0.5 + 0.5 * (textureCoords.xy/textureCoords.w);\n"
8092   "}\n";
8093
8094 const char* const RENDER_SHADOW_FRAGMENT_SOURCE =
8095   "uniform lowp vec4 uShadowColor;\n"
8096   "void main()\n"
8097   "{\n"
8098   "  lowp float alpha;\n"
8099   "  alpha = texture2D(sTexture, vec2(vTexCoord.x, vTexCoord.y)).a;\n"
8100   "  gl_FragColor = vec4(uShadowColor.rgb, uShadowColor.a * alpha);\n"
8101   "}\n";
8102
8103 int utcDaliActorPartialUpdateSetProperty(void)
8104 {
8105   TestApplication application(
8106     TestApplication::DEFAULT_SURFACE_WIDTH,
8107     TestApplication::DEFAULT_SURFACE_HEIGHT,
8108     TestApplication::DEFAULT_HORIZONTAL_DPI,
8109     TestApplication::DEFAULT_VERTICAL_DPI,
8110     true,
8111     true);
8112
8113   tet_infoline("Set/Update property with partial update");
8114
8115   const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
8116
8117   std::vector<Rect<int>> damagedRects;
8118   Rect<int>              clippingRect;
8119   application.SendNotification();
8120   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8121
8122   // First render pass, nothing to render, adaptor would just do swap buffer.
8123   DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
8124   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8125
8126   Texture image = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, 4u, 4u);
8127   Actor   actor = CreateRenderableActor(image, RENDER_SHADOW_VERTEX_SOURCE, RENDER_SHADOW_FRAGMENT_SOURCE);
8128   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
8129   actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
8130   actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
8131   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
8132   application.GetScene().Add(actor);
8133
8134   actor.RegisterProperty(SHADER_SHADOW_COLOR_PROPERTY_NAME, Vector4(1.0f, 0.0f, 0.0f, 1.0f));
8135
8136   damagedRects.clear();
8137   application.SendNotification();
8138   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8139   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
8140
8141   // Aligned by 16
8142   clippingRect = Rect<int>(16, 768, 32, 32); // in screen coordinates, includes 3 last frames updates
8143   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
8144   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8145   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
8146   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
8147   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
8148   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
8149
8150   Property::Index shadowColorPropertyIndex = actor.GetPropertyIndex(SHADER_SHADOW_COLOR_PROPERTY_NAME);
8151   actor.SetProperty(shadowColorPropertyIndex, Vector4(1.0f, 1.0f, 0.0f, 1.0f));
8152
8153   damagedRects.clear();
8154   application.SendNotification();
8155   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8156   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
8157
8158   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
8159   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8160   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
8161   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
8162   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
8163   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
8164
8165   // Should be no damage rects, nothing changed
8166   damagedRects.clear();
8167   application.SendNotification();
8168   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8169   DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
8170
8171   // Should be 1 damage rect due to change in size
8172   damagedRects.clear();
8173   actor.SetProperty(Actor::Property::SIZE, Vector3(26.0f, 26.0f, 0.0f));
8174   application.SendNotification();
8175   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8176   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
8177
8178   clippingRect = Rect<int>(16, 752, 32, 48); // new clipping rect size increased due to change in actor size
8179   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
8180   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8181   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
8182   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
8183   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
8184   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
8185
8186   damagedRects.clear();
8187   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8188   DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
8189
8190   END_TEST;
8191 }
8192
8193 int utcDaliActorPartialUpdateTwoActors(void)
8194 {
8195   TestApplication application(
8196     TestApplication::DEFAULT_SURFACE_WIDTH,
8197     TestApplication::DEFAULT_SURFACE_HEIGHT,
8198     TestApplication::DEFAULT_HORIZONTAL_DPI,
8199     TestApplication::DEFAULT_VERTICAL_DPI,
8200     true,
8201     true);
8202
8203   tet_infoline("Check the damaged rects with partial update and two actors");
8204
8205   const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
8206
8207   Actor actor = CreateRenderableActor();
8208   actor.SetProperty(Actor::Property::POSITION, Vector3(100.0f, 100.0f, 0.0f));
8209   actor.SetProperty(Actor::Property::SIZE, Vector3(50.0f, 50.0f, 0.0f));
8210   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
8211   application.GetScene().Add(actor);
8212
8213   Actor actor2 = CreateRenderableActor();
8214   actor2.SetProperty(Actor::Property::POSITION, Vector3(150.0f, 150.0f, 0.0f));
8215   actor2.SetProperty(Actor::Property::SIZE, Vector3(100.0f, 100.0f, 0.0f));
8216   actor2.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
8217   application.GetScene().Add(actor2);
8218
8219   application.SendNotification();
8220   std::vector<Rect<int>> damagedRects;
8221   application.PreRenderWithPartialUpdate(TestApplication::DEFAULT_RENDER_INTERVAL, nullptr, damagedRects);
8222
8223   DALI_TEST_EQUALS(damagedRects.size(), 2, TEST_LOCATION);
8224   DALI_TEST_EQUALS<Rect<int>>(Rect<int>(64, 672, 64, 64), damagedRects[0], TEST_LOCATION);
8225   DALI_TEST_EQUALS<Rect<int>>(Rect<int>(96, 592, 112, 112), damagedRects[1], TEST_LOCATION);
8226
8227   // in screen coordinates, adaptor would calculate it using previous frames information
8228   Rect<int> clippingRect = Rect<int>(64, 592, 144, 192);
8229   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8230
8231   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
8232   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
8233   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
8234   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
8235
8236   END_TEST;
8237 }
8238
8239 int utcDaliActorPartialUpdateActorsWithSizeHint(void)
8240 {
8241   TestApplication application(
8242     TestApplication::DEFAULT_SURFACE_WIDTH,
8243     TestApplication::DEFAULT_SURFACE_HEIGHT,
8244     TestApplication::DEFAULT_HORIZONTAL_DPI,
8245     TestApplication::DEFAULT_VERTICAL_DPI,
8246     true,
8247     true);
8248
8249   tet_infoline("Check the damaged rect with partial update and actor size hint");
8250
8251   const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
8252
8253   Actor actor = CreateRenderableActor();
8254   actor.SetProperty(Actor::Property::POSITION, Vector3(64.0f, 64.0f, 0.0f));
8255   actor.SetProperty(Actor::Property::SIZE, Vector3(32.0f, 32.0f, 0.0f));
8256   actor.SetProperty(DevelActor::Property::UPDATE_SIZE_HINT, Vector3(64.0f, 64.0f, 0.0f));
8257   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
8258   application.GetScene().Add(actor);
8259
8260   application.SendNotification();
8261   std::vector<Rect<int>> damagedRects;
8262   application.PreRenderWithPartialUpdate(TestApplication::DEFAULT_RENDER_INTERVAL, nullptr, damagedRects);
8263
8264   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
8265
8266   Rect<int> clippingRect = Rect<int>(32, 704, 80, 80);
8267   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
8268
8269   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8270
8271   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
8272   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
8273   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
8274   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
8275
8276   END_TEST;
8277 }
8278
8279 int utcDaliActorPartialUpdateAnimation(void)
8280 {
8281   TestApplication application(
8282     TestApplication::DEFAULT_SURFACE_WIDTH,
8283     TestApplication::DEFAULT_SURFACE_HEIGHT,
8284     TestApplication::DEFAULT_HORIZONTAL_DPI,
8285     TestApplication::DEFAULT_VERTICAL_DPI,
8286     true,
8287     true);
8288
8289   tet_infoline("Check the damaged area with partial update and animation");
8290
8291   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
8292   drawTrace.Enable(true);
8293   drawTrace.Reset();
8294
8295   Actor actor1 = CreateRenderableActor();
8296   actor1.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
8297   actor1.SetProperty(Actor::Property::SIZE, Vector3(80.0f, 80.0f, 0.0f));
8298   application.GetScene().Add(actor1);
8299
8300   Actor actor2 = CreateRenderableActor();
8301   actor2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
8302   actor2.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
8303   application.GetScene().Add(actor2);
8304
8305   std::vector<Rect<int>> damagedRects;
8306   Rect<int>              clippingRect;
8307   Rect<int>              expectedRect1, expectedRect2;
8308
8309   application.SendNotification();
8310   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8311
8312   DALI_TEST_EQUALS(damagedRects.size(), 2, TEST_LOCATION);
8313
8314   // Aligned by 16
8315   expectedRect1 = Rect<int>(0, 720, 96, 96); // in screen coordinates, includes 3 last frames updates
8316   expectedRect2 = Rect<int>(0, 784, 32, 32); // in screen coordinates, includes 3 last frames updates
8317   DALI_TEST_EQUALS<Rect<int>>(expectedRect1, damagedRects[0], TEST_LOCATION);
8318   DALI_TEST_EQUALS<Rect<int>>(expectedRect2, damagedRects[1], TEST_LOCATION);
8319
8320   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8321
8322   damagedRects.clear();
8323   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8324   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8325
8326   // Make an animation
8327   Animation animation = Animation::New(1.0f);
8328   animation.AnimateTo(Property(actor2, Actor::Property::POSITION_X), 160.0f, TimePeriod(0.5f, 0.5f));
8329   animation.Play();
8330
8331   application.SendNotification();
8332
8333   damagedRects.clear();
8334   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8335   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8336
8337   drawTrace.Reset();
8338   damagedRects.clear();
8339
8340   // In animation deley time
8341   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8342   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8343
8344   // Skip rendering
8345   DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION);
8346
8347   drawTrace.Reset();
8348   damagedRects.clear();
8349
8350   // Also in animation deley time
8351   application.PreRenderWithPartialUpdate(100, nullptr, damagedRects);
8352   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8353
8354   // Skip rendering
8355   DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION);
8356
8357   // Unparent 2 actors and make a new actor
8358   actor1.Unparent();
8359   actor2.Unparent();
8360
8361   Actor actor3 = CreateRenderableActor();
8362   actor3.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
8363   actor3.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
8364   application.GetScene().Add(actor3);
8365
8366   application.SendNotification();
8367
8368   // Started animation
8369   damagedRects.clear();
8370   application.PreRenderWithPartialUpdate(500, nullptr, damagedRects);
8371   DALI_TEST_EQUALS(damagedRects.size(), 5, TEST_LOCATION);
8372
8373   // The first dirty rect is actor3's.
8374   // We don't know the exact dirty rect of actor2
8375   DALI_TEST_EQUALS<Rect<int>>(expectedRect2, damagedRects[0], TEST_LOCATION);
8376   DALI_TEST_EQUALS<Rect<int>>(expectedRect1, damagedRects[1], TEST_LOCATION);
8377
8378   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8379
8380   // Finished animation, but the actior was already unparented
8381   damagedRects.clear();
8382   application.PreRenderWithPartialUpdate(500, nullptr, damagedRects);
8383
8384   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
8385   DALI_TEST_EQUALS<Rect<int>>(expectedRect2, damagedRects[0], TEST_LOCATION);
8386
8387   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8388
8389   END_TEST;
8390 }
8391
8392 int utcDaliActorPartialUpdateChangeVisibility(void)
8393 {
8394   TestApplication application(
8395     TestApplication::DEFAULT_SURFACE_WIDTH,
8396     TestApplication::DEFAULT_SURFACE_HEIGHT,
8397     TestApplication::DEFAULT_HORIZONTAL_DPI,
8398     TestApplication::DEFAULT_VERTICAL_DPI,
8399     true,
8400     true);
8401
8402   tet_infoline("Check the damaged rect with partial update and visibility change");
8403
8404   const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
8405
8406   Actor actor = CreateRenderableActor();
8407   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
8408   actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
8409   actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
8410   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
8411   application.GetScene().Add(actor);
8412
8413   application.SendNotification();
8414
8415   std::vector<Rect<int>> damagedRects;
8416   Rect<int>              clippingRect;
8417
8418   // 1. Actor added, damaged rect is added size of actor
8419   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8420   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
8421
8422   // Aligned by 16
8423   clippingRect = Rect<int>(16, 768, 32, 32); // in screen coordinates, includes 3 last frames updates
8424   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
8425   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8426   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
8427   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
8428   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
8429   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
8430
8431   damagedRects.clear();
8432   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8433   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8434
8435   damagedRects.clear();
8436   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8437   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8438
8439   // Ensure the damaged rect is empty
8440   DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
8441
8442   // 2. Make the Actor invisible
8443   actor.SetProperty(Actor::Property::VISIBLE, false);
8444   application.SendNotification();
8445
8446   damagedRects.clear();
8447   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8448   DALI_TEST_CHECK(damagedRects.size() > 0);
8449   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
8450
8451   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8452   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
8453   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
8454   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
8455   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
8456
8457   // 3. Make the Actor visible again
8458   actor.SetProperty(Actor::Property::VISIBLE, true);
8459   application.SendNotification();
8460
8461   damagedRects.clear();
8462   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8463   DALI_TEST_CHECK(damagedRects.size() > 0);
8464   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
8465
8466   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8467   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
8468   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
8469   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
8470   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
8471
8472   END_TEST;
8473 }
8474
8475 int utcDaliActorPartialUpdateOnOffScene(void)
8476 {
8477   TestApplication application(
8478     TestApplication::DEFAULT_SURFACE_WIDTH,
8479     TestApplication::DEFAULT_SURFACE_HEIGHT,
8480     TestApplication::DEFAULT_HORIZONTAL_DPI,
8481     TestApplication::DEFAULT_VERTICAL_DPI,
8482     true,
8483     true);
8484
8485   tet_infoline("Check the damaged rect with partial update and on/off scene");
8486
8487   const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
8488
8489   Actor actor = CreateRenderableActor();
8490   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
8491   actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
8492   actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
8493   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
8494   application.GetScene().Add(actor);
8495
8496   application.SendNotification();
8497
8498   std::vector<Rect<int>> damagedRects;
8499   Rect<int>              clippingRect;
8500
8501   // 1. Actor added, damaged rect is added size of actor
8502   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8503   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
8504
8505   // Aligned by 16
8506   clippingRect = Rect<int>(16, 768, 32, 32); // in screen coordinates, includes 3 last frames updates
8507   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
8508   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8509   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
8510   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
8511   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
8512   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
8513
8514   damagedRects.clear();
8515   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8516   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8517
8518   damagedRects.clear();
8519   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8520   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8521
8522   // Ensure the damaged rect is empty
8523   DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
8524
8525   // 2. Remove the Actor from the Scene
8526   actor.Unparent();
8527   application.SendNotification();
8528
8529   damagedRects.clear();
8530   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8531   DALI_TEST_CHECK(damagedRects.size() > 0);
8532   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
8533
8534   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8535   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
8536   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
8537   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
8538   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
8539
8540   // 3. Add the Actor to the Scene again
8541   application.GetScene().Add(actor);
8542   application.SendNotification();
8543
8544   damagedRects.clear();
8545   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
8546   DALI_TEST_CHECK(damagedRects.size() > 0);
8547   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
8548
8549   application.RenderWithPartialUpdate(damagedRects, clippingRect);
8550   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
8551   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
8552   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
8553   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
8554
8555   END_TEST;
8556 }
8557
8558 int UtcDaliActorCaptureAllTouchAfterStartPropertyP(void)
8559 {
8560   TestApplication application;
8561
8562   Actor actor = Actor::New();
8563   DALI_TEST_EQUALS(actor.GetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START).Get<bool>(), false, TEST_LOCATION);
8564   actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, true);
8565   DALI_TEST_EQUALS(actor.GetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START).Get<bool>(), true, TEST_LOCATION);
8566   DALI_TEST_EQUALS(actor.GetPropertyType(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), Property::BOOLEAN, TEST_LOCATION);
8567   DALI_TEST_EQUALS(actor.IsPropertyWritable(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), true, TEST_LOCATION);
8568   DALI_TEST_EQUALS(actor.IsPropertyAnimatable(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), false, TEST_LOCATION);
8569   DALI_TEST_EQUALS(actor.IsPropertyAConstraintInput(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), false, TEST_LOCATION);
8570   DALI_TEST_EQUALS(actor.GetPropertyName(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), "captureAllTouchAfterStart", TEST_LOCATION);
8571   END_TEST;
8572 }
8573
8574 int UtcDaliActorCaptureAllTouchAfterStartPropertyN(void)
8575 {
8576   TestApplication application;
8577
8578   Actor actor = Actor::New();
8579
8580   // Make sure setting invalid types does not cause a crash
8581   try
8582   {
8583     actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, 1.0f);
8584     actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Vector2::ONE);
8585     actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Vector3::ONE);
8586     actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Vector4::ONE);
8587     actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Property::Map());
8588     actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Property::Array());
8589     tet_result(TET_PASS);
8590   }
8591   catch(...)
8592   {
8593     tet_result(TET_FAIL);
8594   }
8595   END_TEST;
8596 }
8597
8598 int UtcDaliActorTouchAreaPropertyP(void)
8599 {
8600   TestApplication application;
8601
8602   Actor   actor     = Actor::New();
8603   Vector2 touchArea = actor.GetProperty(DevelActor::Property::TOUCH_AREA).Get<Vector2>();
8604   DALI_TEST_EQUALS(touchArea, Vector2::ZERO, TEST_LOCATION);
8605   actor.SetProperty(DevelActor::Property::TOUCH_AREA, Vector2(10.f, 10.f));
8606   touchArea = actor.GetProperty(DevelActor::Property::TOUCH_AREA).Get<Vector2>();
8607   DALI_TEST_EQUALS(touchArea, Vector2(10.f, 10.f), TEST_LOCATION);
8608   END_TEST;
8609 }
8610
8611 int UtcDaliActorTouchAreaPropertyN(void)
8612 {
8613   TestApplication application;
8614
8615   Actor actor = Actor::New();
8616
8617   // Make sure setting invalid types does not cause a crash
8618   try
8619   {
8620     actor.SetProperty(DevelActor::Property::TOUCH_AREA, 1.0f);
8621     actor.SetProperty(DevelActor::Property::TOUCH_AREA, Vector2::ONE);
8622     actor.SetProperty(DevelActor::Property::TOUCH_AREA, Vector3::ONE);
8623     actor.SetProperty(DevelActor::Property::TOUCH_AREA, Vector4::ONE);
8624     actor.SetProperty(DevelActor::Property::TOUCH_AREA, Property::Map());
8625     actor.SetProperty(DevelActor::Property::TOUCH_AREA, Property::Array());
8626     tet_result(TET_PASS);
8627   }
8628   catch(...)
8629   {
8630     tet_result(TET_FAIL);
8631   }
8632   END_TEST;
8633 }
8634
8635 int UtcDaliActorLowerBelowNegative(void)
8636 {
8637   TestApplication application;
8638   Dali::Actor     instance;
8639   try
8640   {
8641     Dali::Actor arg1;
8642     instance.LowerBelow(arg1);
8643     DALI_TEST_CHECK(false); // Should not get here
8644   }
8645   catch(...)
8646   {
8647     DALI_TEST_CHECK(true); // We expect an assert
8648   }
8649   END_TEST;
8650 }
8651
8652 int UtcDaliActorRaiseAboveNegative(void)
8653 {
8654   TestApplication application;
8655   Dali::Actor     instance;
8656   try
8657   {
8658     Dali::Actor arg1;
8659     instance.RaiseAbove(arg1);
8660     DALI_TEST_CHECK(false); // Should not get here
8661   }
8662   catch(...)
8663   {
8664     DALI_TEST_CHECK(true); // We expect an assert
8665   }
8666   END_TEST;
8667 }
8668
8669 int UtcDaliActorRaiseToTopNegative(void)
8670 {
8671   TestApplication application;
8672   Dali::Actor     instance;
8673   try
8674   {
8675     instance.RaiseToTop();
8676     DALI_TEST_CHECK(false); // Should not get here
8677   }
8678   catch(...)
8679   {
8680     DALI_TEST_CHECK(true); // We expect an assert
8681   }
8682   END_TEST;
8683 }
8684
8685 int UtcDaliActorAddRendererNegative(void)
8686 {
8687   TestApplication application;
8688   Dali::Actor     instance;
8689   try
8690   {
8691     Dali::Renderer arg1;
8692     instance.AddRenderer(arg1);
8693     DALI_TEST_CHECK(false); // Should not get here
8694   }
8695   catch(...)
8696   {
8697     DALI_TEST_CHECK(true); // We expect an assert
8698   }
8699   END_TEST;
8700 }
8701
8702 int UtcDaliActorTouchedSignalNegative(void)
8703 {
8704   TestApplication application;
8705   Dali::Actor     instance;
8706   try
8707   {
8708     instance.TouchedSignal();
8709     DALI_TEST_CHECK(false); // Should not get here
8710   }
8711   catch(...)
8712   {
8713     DALI_TEST_CHECK(true); // We expect an assert
8714   }
8715   END_TEST;
8716 }
8717
8718 int UtcDaliActorTranslateByNegative(void)
8719 {
8720   TestApplication application;
8721   Dali::Actor     instance;
8722   try
8723   {
8724     Dali::Vector3 arg1;
8725     instance.TranslateBy(arg1);
8726     DALI_TEST_CHECK(false); // Should not get here
8727   }
8728   catch(...)
8729   {
8730     DALI_TEST_CHECK(true); // We expect an assert
8731   }
8732   END_TEST;
8733 }
8734
8735 int UtcDaliActorFindChildByIdNegative(void)
8736 {
8737   TestApplication application;
8738   Dali::Actor     instance;
8739   try
8740   {
8741     unsigned int arg1 = 0u;
8742     instance.FindChildById(arg1);
8743     DALI_TEST_CHECK(false); // Should not get here
8744   }
8745   catch(...)
8746   {
8747     DALI_TEST_CHECK(true); // We expect an assert
8748   }
8749   END_TEST;
8750 }
8751
8752 int UtcDaliActorGetRendererAtNegative(void)
8753 {
8754   TestApplication application;
8755   Dali::Actor     instance;
8756   try
8757   {
8758     unsigned int arg1 = 0u;
8759     instance.GetRendererAt(arg1);
8760     DALI_TEST_CHECK(false); // Should not get here
8761   }
8762   catch(...)
8763   {
8764     DALI_TEST_CHECK(true); // We expect an assert
8765   }
8766   END_TEST;
8767 }
8768
8769 int UtcDaliActorHoveredSignalNegative(void)
8770 {
8771   TestApplication application;
8772   Dali::Actor     instance;
8773   try
8774   {
8775     instance.HoveredSignal();
8776     DALI_TEST_CHECK(false); // Should not get here
8777   }
8778   catch(...)
8779   {
8780     DALI_TEST_CHECK(true); // We expect an assert
8781   }
8782   END_TEST;
8783 }
8784
8785 int UtcDaliActorLowerToBottomNegative(void)
8786 {
8787   TestApplication application;
8788   Dali::Actor     instance;
8789   try
8790   {
8791     instance.LowerToBottom();
8792     DALI_TEST_CHECK(false); // Should not get here
8793   }
8794   catch(...)
8795   {
8796     DALI_TEST_CHECK(true); // We expect an assert
8797   }
8798   END_TEST;
8799 }
8800
8801 int UtcDaliActorOnSceneSignalNegative(void)
8802 {
8803   TestApplication application;
8804   Dali::Actor     instance;
8805   try
8806   {
8807     instance.OnSceneSignal();
8808     DALI_TEST_CHECK(false); // Should not get here
8809   }
8810   catch(...)
8811   {
8812     DALI_TEST_CHECK(true); // We expect an assert
8813   }
8814   END_TEST;
8815 }
8816
8817 int UtcDaliActorOffSceneSignalNegative(void)
8818 {
8819   TestApplication application;
8820   Dali::Actor     instance;
8821   try
8822   {
8823     instance.OffSceneSignal();
8824     DALI_TEST_CHECK(false); // Should not get here
8825   }
8826   catch(...)
8827   {
8828     DALI_TEST_CHECK(true); // We expect an assert
8829   }
8830   END_TEST;
8831 }
8832
8833 int UtcDaliActorRemoveRendererNegative01(void)
8834 {
8835   TestApplication application;
8836   Dali::Actor     instance;
8837   try
8838   {
8839     unsigned int arg1 = 0u;
8840     instance.RemoveRenderer(arg1);
8841     DALI_TEST_CHECK(false); // Should not get here
8842   }
8843   catch(...)
8844   {
8845     DALI_TEST_CHECK(true); // We expect an assert
8846   }
8847   END_TEST;
8848 }
8849
8850 int UtcDaliActorRemoveRendererNegative02(void)
8851 {
8852   TestApplication application;
8853   Dali::Actor     instance;
8854   try
8855   {
8856     Dali::Renderer arg1;
8857     instance.RemoveRenderer(arg1);
8858     DALI_TEST_CHECK(false); // Should not get here
8859   }
8860   catch(...)
8861   {
8862     DALI_TEST_CHECK(true); // We expect an assert
8863   }
8864   END_TEST;
8865 }
8866
8867 int UtcDaliActorFindChildByNameNegative(void)
8868 {
8869   TestApplication application;
8870   Dali::Actor     instance;
8871   try
8872   {
8873     std::string arg1;
8874     instance.FindChildByName(arg1);
8875     DALI_TEST_CHECK(false); // Should not get here
8876   }
8877   catch(...)
8878   {
8879     DALI_TEST_CHECK(true); // We expect an assert
8880   }
8881   END_TEST;
8882 }
8883
8884 int UtcDaliActorSetResizePolicyNegative(void)
8885 {
8886   TestApplication application;
8887   Dali::Actor     instance;
8888   try
8889   {
8890     Dali::ResizePolicy::Type arg1 = ResizePolicy::USE_NATURAL_SIZE;
8891     Dali::Dimension::Type    arg2 = Dimension::ALL_DIMENSIONS;
8892     instance.SetResizePolicy(arg1, arg2);
8893     DALI_TEST_CHECK(false); // Should not get here
8894   }
8895   catch(...)
8896   {
8897     DALI_TEST_CHECK(true); // We expect an assert
8898   }
8899   END_TEST;
8900 }
8901
8902 int UtcDaliActorOnRelayoutSignalNegative(void)
8903 {
8904   TestApplication application;
8905   Dali::Actor     instance;
8906   try
8907   {
8908     instance.OnRelayoutSignal();
8909     DALI_TEST_CHECK(false); // Should not get here
8910   }
8911   catch(...)
8912   {
8913     DALI_TEST_CHECK(true); // We expect an assert
8914   }
8915   END_TEST;
8916 }
8917
8918 int UtcDaliActorWheelEventSignalNegative(void)
8919 {
8920   TestApplication application;
8921   Dali::Actor     instance;
8922   try
8923   {
8924     instance.WheelEventSignal();
8925     DALI_TEST_CHECK(false); // Should not get here
8926   }
8927   catch(...)
8928   {
8929     DALI_TEST_CHECK(true); // We expect an assert
8930   }
8931   END_TEST;
8932 }
8933
8934 int UtcDaliActorGetHeightForWidthNegative(void)
8935 {
8936   TestApplication application;
8937   Dali::Actor     instance;
8938   try
8939   {
8940     float arg1 = 0.0f;
8941     instance.GetHeightForWidth(arg1);
8942     DALI_TEST_CHECK(false); // Should not get here
8943   }
8944   catch(...)
8945   {
8946     DALI_TEST_CHECK(true); // We expect an assert
8947   }
8948   END_TEST;
8949 }
8950
8951 int UtcDaliActorGetWidthForHeightNegative(void)
8952 {
8953   TestApplication application;
8954   Dali::Actor     instance;
8955   try
8956   {
8957     float arg1 = 0.0f;
8958     instance.GetWidthForHeight(arg1);
8959     DALI_TEST_CHECK(false); // Should not get here
8960   }
8961   catch(...)
8962   {
8963     DALI_TEST_CHECK(true); // We expect an assert
8964   }
8965   END_TEST;
8966 }
8967
8968 int UtcDaliActorLayoutDirectionChangedSignalNegative(void)
8969 {
8970   TestApplication application;
8971   Dali::Actor     instance;
8972   try
8973   {
8974     instance.LayoutDirectionChangedSignal();
8975     DALI_TEST_CHECK(false); // Should not get here
8976   }
8977   catch(...)
8978   {
8979     DALI_TEST_CHECK(true); // We expect an assert
8980   }
8981   END_TEST;
8982 }
8983
8984 int UtcDaliActorAddNegative(void)
8985 {
8986   TestApplication application;
8987   Dali::Actor     instance;
8988   try
8989   {
8990     Dali::Actor arg1;
8991     instance.Add(arg1);
8992     DALI_TEST_CHECK(false); // Should not get here
8993   }
8994   catch(...)
8995   {
8996     DALI_TEST_CHECK(true); // We expect an assert
8997   }
8998   END_TEST;
8999 }
9000
9001 int UtcDaliActorLowerNegative(void)
9002 {
9003   TestApplication application;
9004   Dali::Actor     instance;
9005   try
9006   {
9007     instance.Lower();
9008     DALI_TEST_CHECK(false); // Should not get here
9009   }
9010   catch(...)
9011   {
9012     DALI_TEST_CHECK(true); // We expect an assert
9013   }
9014   END_TEST;
9015 }
9016
9017 int UtcDaliActorRaiseNegative(void)
9018 {
9019   TestApplication application;
9020   Dali::Actor     instance;
9021   try
9022   {
9023     instance.Raise();
9024     DALI_TEST_CHECK(false); // Should not get here
9025   }
9026   catch(...)
9027   {
9028     DALI_TEST_CHECK(true); // We expect an assert
9029   }
9030   END_TEST;
9031 }
9032
9033 int UtcDaliActorRemoveNegative(void)
9034 {
9035   TestApplication application;
9036   Dali::Actor     instance;
9037   try
9038   {
9039     Dali::Actor arg1;
9040     instance.Remove(arg1);
9041     DALI_TEST_CHECK(false); // Should not get here
9042   }
9043   catch(...)
9044   {
9045     DALI_TEST_CHECK(true); // We expect an assert
9046   }
9047   END_TEST;
9048 }
9049
9050 int UtcDaliActorScaleByNegative(void)
9051 {
9052   TestApplication application;
9053   Dali::Actor     instance;
9054   try
9055   {
9056     Dali::Vector3 arg1;
9057     instance.ScaleBy(arg1);
9058     DALI_TEST_CHECK(false); // Should not get here
9059   }
9060   catch(...)
9061   {
9062     DALI_TEST_CHECK(true); // We expect an assert
9063   }
9064   END_TEST;
9065 }
9066
9067 int UtcDaliActorGetLayerNegative(void)
9068 {
9069   TestApplication application;
9070   Dali::Actor     instance;
9071   try
9072   {
9073     instance.GetLayer();
9074     DALI_TEST_CHECK(false); // Should not get here
9075   }
9076   catch(...)
9077   {
9078     DALI_TEST_CHECK(true); // We expect an assert
9079   }
9080   END_TEST;
9081 }
9082
9083 int UtcDaliActorRotateByNegative01(void)
9084 {
9085   TestApplication application;
9086   Dali::Actor     instance;
9087   try
9088   {
9089     Dali::Quaternion arg1;
9090     instance.RotateBy(arg1);
9091     DALI_TEST_CHECK(false); // Should not get here
9092   }
9093   catch(...)
9094   {
9095     DALI_TEST_CHECK(true); // We expect an assert
9096   }
9097   END_TEST;
9098 }
9099
9100 int UtcDaliActorRotateByNegative02(void)
9101 {
9102   TestApplication application;
9103   Dali::Actor     instance;
9104   try
9105   {
9106     Dali::Radian  arg1;
9107     Dali::Vector3 arg2;
9108     instance.RotateBy(arg1, arg2);
9109     DALI_TEST_CHECK(false); // Should not get here
9110   }
9111   catch(...)
9112   {
9113     DALI_TEST_CHECK(true); // We expect an assert
9114   }
9115   END_TEST;
9116 }
9117
9118 int UtcDaliActorUnparentNegative(void)
9119 {
9120   TestApplication application;
9121   Dali::Actor     instance;
9122   try
9123   {
9124     instance.Unparent();
9125     DALI_TEST_CHECK(false); // Should not get here
9126   }
9127   catch(...)
9128   {
9129     DALI_TEST_CHECK(true); // We expect an assert
9130   }
9131   END_TEST;
9132 }
9133
9134 int UtcDaliActorGetChildAtNegative(void)
9135 {
9136   TestApplication application;
9137   Dali::Actor     instance;
9138   try
9139   {
9140     unsigned int arg1 = 0u;
9141     instance.GetChildAt(arg1);
9142     DALI_TEST_CHECK(false); // Should not get here
9143   }
9144   catch(...)
9145   {
9146     DALI_TEST_CHECK(true); // We expect an assert
9147   }
9148   END_TEST;
9149 }
9150
9151 int UtcDaliActorGetChildCountNegative(void)
9152 {
9153   TestApplication application;
9154   Dali::Actor     instance;
9155   try
9156   {
9157     instance.GetChildCount();
9158     DALI_TEST_CHECK(false); // Should not get here
9159   }
9160   catch(...)
9161   {
9162     DALI_TEST_CHECK(true); // We expect an assert
9163   }
9164   END_TEST;
9165 }
9166
9167 int UtcDaliActorGetTargetSizeNegative(void)
9168 {
9169   TestApplication application;
9170   Dali::Actor     instance;
9171   try
9172   {
9173     instance.GetTargetSize();
9174     DALI_TEST_CHECK(false); // Should not get here
9175   }
9176   catch(...)
9177   {
9178     DALI_TEST_CHECK(true); // We expect an assert
9179   }
9180   END_TEST;
9181 }
9182
9183 int UtcDaliActorScreenToLocalNegative(void)
9184 {
9185   TestApplication application;
9186   Dali::Actor     instance;
9187   try
9188   {
9189     float arg1 = 0.0f;
9190     float arg2 = 0.0f;
9191     float arg3 = 0.0f;
9192     float arg4 = 0.0f;
9193     instance.ScreenToLocal(arg1, arg2, arg3, arg4);
9194     DALI_TEST_CHECK(false); // Should not get here
9195   }
9196   catch(...)
9197   {
9198     DALI_TEST_CHECK(true); // We expect an assert
9199   }
9200   END_TEST;
9201 }
9202
9203 int UtcDaliActorGetNaturalSizeNegative(void)
9204 {
9205   TestApplication application;
9206   Dali::Actor     instance;
9207   try
9208   {
9209     instance.GetNaturalSize();
9210     DALI_TEST_CHECK(false); // Should not get here
9211   }
9212   catch(...)
9213   {
9214     DALI_TEST_CHECK(true); // We expect an assert
9215   }
9216   END_TEST;
9217 }
9218
9219 int UtcDaliActorGetRelayoutSizeNegative(void)
9220 {
9221   TestApplication application;
9222   Dali::Actor     instance;
9223   try
9224   {
9225     Dali::Dimension::Type arg1 = Dimension::HEIGHT;
9226     instance.GetRelayoutSize(arg1);
9227     DALI_TEST_CHECK(false); // Should not get here
9228   }
9229   catch(...)
9230   {
9231     DALI_TEST_CHECK(true); // We expect an assert
9232   }
9233   END_TEST;
9234 }
9235
9236 int UtcDaliActorGetResizePolicyNegative(void)
9237 {
9238   TestApplication application;
9239   Dali::Actor     instance;
9240   try
9241   {
9242     Dali::Dimension::Type arg1 = Dimension::ALL_DIMENSIONS;
9243     instance.GetResizePolicy(arg1);
9244     DALI_TEST_CHECK(false); // Should not get here
9245   }
9246   catch(...)
9247   {
9248     DALI_TEST_CHECK(true); // We expect an assert
9249   }
9250   END_TEST;
9251 }
9252
9253 int UtcDaliActorGetRendererCountNegative(void)
9254 {
9255   TestApplication application;
9256   Dali::Actor     instance;
9257   try
9258   {
9259     instance.GetRendererCount();
9260     DALI_TEST_CHECK(false); // Should not get here
9261   }
9262   catch(...)
9263   {
9264     DALI_TEST_CHECK(true); // We expect an assert
9265   }
9266   END_TEST;
9267 }
9268
9269 int UtcDaliActorGetParentNegative(void)
9270 {
9271   TestApplication application;
9272   Dali::Actor     instance;
9273   try
9274   {
9275     instance.GetParent();
9276     DALI_TEST_CHECK(false); // Should not get here
9277   }
9278   catch(...)
9279   {
9280     DALI_TEST_CHECK(true); // We expect an assert
9281   }
9282   END_TEST;
9283 }
9284
9285 int UtcDaliActorPropertyBlendEquation(void)
9286 {
9287   TestApplication application;
9288
9289   tet_infoline("Test SetProperty AdvancedBlendEquation");
9290
9291   Geometry geometry  = CreateQuadGeometry();
9292   Shader   shader    = CreateShader();
9293   Renderer renderer1 = Renderer::New(geometry, shader);
9294
9295   Actor actor = Actor::New();
9296   actor.SetProperty(Actor::Property::OPACITY, 0.1f);
9297
9298   actor.AddRenderer(renderer1);
9299   actor.SetProperty(Actor::Property::SIZE, Vector2(400, 400));
9300   application.GetScene().Add(actor);
9301
9302   if(!Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::SCREEN))
9303   {
9304     actor.SetProperty(Dali::DevelActor::Property::BLEND_EQUATION, Dali::DevelBlendEquation::SCREEN);
9305     int equation = actor.GetProperty<int>(Dali::DevelActor::Property::BLEND_EQUATION);
9306     DALI_TEST_EQUALS((Dali::DevelBlendEquation::SCREEN == equation), false, TEST_LOCATION);
9307   }
9308
9309   if(Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::SCREEN))
9310   {
9311     actor.SetProperty(Dali::DevelActor::Property::BLEND_EQUATION, Dali::DevelBlendEquation::SCREEN);
9312     int equation = actor.GetProperty<int>(Dali::DevelActor::Property::BLEND_EQUATION);
9313     DALI_TEST_EQUALS((Dali::DevelBlendEquation::SCREEN == equation), true, TEST_LOCATION);
9314   }
9315
9316   Renderer renderer2 = Renderer::New(geometry, shader);
9317   actor.AddRenderer(renderer2);
9318
9319   END_TEST;
9320 }
9321
9322 int UtcDaliActorRegisterProperty(void)
9323 {
9324   tet_infoline("Test property registration and uniform map update\n");
9325
9326   TestApplication application;
9327
9328   Geometry geometry  = CreateQuadGeometry();
9329   Shader   shader    = CreateShader();
9330   Renderer renderer1 = Renderer::New(geometry, shader);
9331   Renderer renderer2 = Renderer::New(geometry, shader);
9332
9333   Actor actor1 = Actor::New();
9334   actor1.AddRenderer(renderer1);
9335   actor1.SetProperty(Actor::Property::SIZE, Vector2(100, 100));
9336   actor1.RegisterProperty("uCustom", 1);
9337   application.GetScene().Add(actor1);
9338
9339   Actor actor2 = Actor::New();
9340   actor2.AddRenderer(renderer2);
9341   actor2.SetProperty(Actor::Property::SIZE, Vector2(100, 100));
9342   application.GetScene().Add(actor2);
9343
9344   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
9345   TraceCallStack&    callStack     = glAbstraction.GetSetUniformTrace();
9346   glAbstraction.EnableSetUniformCallTrace(true);
9347
9348   application.SendNotification();
9349   application.Render();
9350
9351   std::stringstream out;
9352   out.str("1");
9353   std::string params;
9354
9355   // Test uniform value of the custom property
9356   DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("uCustom", params));
9357   DALI_TEST_EQUALS(out.str(), params, TEST_LOCATION);
9358
9359   // Make invisible
9360   actor1[Actor::Property::VISIBLE] = false;
9361
9362   application.SendNotification();
9363   application.Render();
9364
9365   // Make visible again
9366   actor1[Actor::Property::VISIBLE] = true;
9367   actor1["uCustom"]                = 2;
9368
9369   glAbstraction.ResetSetUniformCallStack();
9370
9371   application.SendNotification();
9372   application.Render();
9373
9374   out.str("2");
9375
9376   // The uniform value should not be changed
9377   DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("uCustom", params));
9378   DALI_TEST_EQUALS(out.str(), params, TEST_LOCATION);
9379
9380   END_TEST;
9381 }