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