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

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