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