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

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <dali-test-suite-utils.h>
  19 #include <dali/public-api/dali-core.h>
  20 #include <stdlib.h>
  21
  22 #include <iostream>
  23
  24 using namespace Dali;
  25
  26 void utc_dali_property_notification_startup(void)
  27 {
  28   test_return_value = TET_UNDEF;
  29 }
  30
  31 void utc_dali_property_notification_cleanup(void)
  32 {
  33   test_return_value = TET_PASS;
  34 }
  35
  36 namespace
  37 {
  38 static bool gCallBackCalled;
  39
  40 static void TestCallback(PropertyNotification& source)
  41 {
  42   gCallBackCalled = true;
  43 }
  44
  45 const int RENDER_FRAME_INTERVAL(16); ///< Duration of each frame in ms. (at approx 60FPS)
  46 const int DEFAULT_WAIT_PERIOD(100);  ///< Default waiting period for check.
  47
  48 class TestClass : public ConnectionTracker
  49 {
  50 public:
  51   TestClass(Integration::Scene scene)
  52   : mScene(scene)
  53   {
  54   }
  55
  56   ~TestClass()
  57   {
  58   }
  59
  60   void Initialize()
  61   {
  62     mActor = Actor::New();
  63     mScene.Add(mActor);
  64     mNotification = mActor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(100.0f));
  65     mNotification.NotifySignal().Connect(this, &TestClass::OnPropertyNotify);
  66   }
  67
  68   void RemovePropertyNotification()
  69   {
  70     mActor.RemovePropertyNotification(mNotification);
  71   }
  72
  73   void RemovePropertyNotifications()
  74   {
  75     mActor.RemovePropertyNotifications();
  76   }
  77
  78   void Terminate()
  79   {
  80     mScene.Remove(mActor);
  81     mActor.Reset();
  82     mNotification.Reset();
  83   }
  84
  85   void OnPropertyNotify(PropertyNotification& source)
  86   {
  87     tet_infoline(" OnPropertyNotify");
  88     gCallBackCalled = true;
  89   }
  90
  91   Actor                mActor;
  92   PropertyNotification mNotification;
  93   Integration::Scene   mScene;
  94 };
  95
  96 /*
  97  * Simulate time passed by.
  98  *
  99  * @note this will always process at least 1 frame (1/60 sec)
 100  *
 101  * @param application Test application instance
 102  * @param duration Time to pass in milliseconds.
 103  * @return The actual time passed in milliseconds
 104  */
 105 int Wait(TestApplication& application, int duration = 0)
 106 {
 107   int time = 0;
 108
 109   for(int i = 0; i <= (duration / RENDER_FRAME_INTERVAL); i++)
 110   {
 111     application.SendNotification();
 112     application.Render(RENDER_FRAME_INTERVAL);
 113     time += RENDER_FRAME_INTERVAL;
 114   }
 115
 116   return time;
 117 }
 118
 119 } // unnamed namespace
 120
 121 // Positive test case for a method
 122 int UtcDaliPropertyNotificationDownCast(void)
 123 {
 124   TestApplication application;
 125   tet_infoline(" UtcDaliPropertyNotificationDownCast");
 126
 127   Actor                actor        = Actor::New();
 128   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(100.0f));
 129   BaseHandle           handle       = notification;
 130   PropertyNotification notificationHandle;
 131
 132   DALI_TEST_CHECK(notification);
 133   DALI_TEST_CHECK(handle);
 134   DALI_TEST_CHECK(!notificationHandle);
 135
 136   notificationHandle = PropertyNotification::DownCast(handle);
 137   DALI_TEST_CHECK(notificationHandle);
 138   END_TEST;
 139 }
 140
 141 // Negative test case for a method
 142 int UtcDaliPropertyNotificationDownCastNegative(void)
 143 {
 144   TestApplication application;
 145   tet_infoline(" UtcDaliPropertyNotificationDownCastNegative");
 146
 147   // Create something derived from BaseHandle other than a PropertyNotification.
 148   Actor somethingElse = Actor::New();
 149
 150   Actor actor = Actor::New();
 151   actor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(100.0f));
 152   BaseHandle           handle = somethingElse;
 153   PropertyNotification notificationHandle;
 154
 155   notificationHandle = PropertyNotification::DownCast(handle);
 156   DALI_TEST_CHECK(!notificationHandle);
 157   END_TEST;
 158 }
 159
 160 int UtcDaliPropertyNotificationMoveConstructor(void)
 161 {
 162   TestApplication application;
 163
 164   Actor actor = Actor::New();
 165
 166   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(100.0f));
 167   DALI_TEST_CHECK(notification);
 168   DALI_TEST_EQUALS(2, notification.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 169
 170   PropertyNotification movedNotification = std::move(notification);
 171   DALI_TEST_CHECK(movedNotification);
 172
 173   // Check that object is moved (not copied, so ref count keeps the same)
 174   DALI_TEST_EQUALS(2, movedNotification.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 175   DALI_TEST_CHECK(!notification);
 176
 177   PropertyCondition condition = movedNotification.GetCondition();
 178   DALI_TEST_CHECK(condition);
 179   DALI_TEST_EQUALS(2, condition.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 180   DALI_TEST_EQUALS(1, condition.GetArgumentCount(), TEST_LOCATION);
 181
 182   PropertyCondition movedCondition = std::move(condition);
 183   DALI_TEST_CHECK(movedCondition);
 184
 185   // Check that object is moved (not copied, so ref count keeps the same)
 186   DALI_TEST_EQUALS(2, movedCondition.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 187   DALI_TEST_EQUALS(1, movedCondition.GetArgumentCount(), TEST_LOCATION);
 188   DALI_TEST_CHECK(!condition);
 189
 190   END_TEST;
 191 }
 192
 193 int UtcDaliPropertyNotificationMoveAssignment(void)
 194 {
 195   TestApplication application;
 196
 197   Actor actor = Actor::New();
 198
 199   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(100.0f));
 200   DALI_TEST_CHECK(notification);
 201   DALI_TEST_EQUALS(2, notification.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 202
 203   PropertyNotification movedNotification;
 204   movedNotification = std::move(notification);
 205   DALI_TEST_CHECK(movedNotification);
 206
 207   // Check that object is moved (not copied, so ref count keeps the same)
 208   DALI_TEST_EQUALS(2, movedNotification.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 209   DALI_TEST_CHECK(!notification);
 210
 211   PropertyCondition condition = movedNotification.GetCondition();
 212   DALI_TEST_CHECK(condition);
 213   DALI_TEST_EQUALS(2, condition.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 214   DALI_TEST_EQUALS(1, condition.GetArgumentCount(), TEST_LOCATION);
 215
 216   PropertyCondition movedCondition;
 217   movedCondition = std::move(condition);
 218   DALI_TEST_CHECK(movedCondition);
 219
 220   // Check that object is moved (not copied, so ref count keeps the same)
 221   DALI_TEST_EQUALS(2, movedCondition.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 222   DALI_TEST_EQUALS(1, movedCondition.GetArgumentCount(), TEST_LOCATION);
 223   DALI_TEST_CHECK(!condition);
 224
 225   END_TEST;
 226 }
 227
 228 int UtcDaliAddPropertyNotification(void)
 229 {
 230   TestApplication application; // Reset all test adapter return codes
 231   tet_infoline(" UtcDaliAddPropertyNotification");
 232
 233   Actor actor = Actor::New();
 234
 235   PropertyNotification notification  = actor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(100.0f));
 236   PropertyNotification notification2 = actor.AddPropertyNotification(Actor::Property::SIZE, StepCondition(1.0f, 1.0f));
 237   DALI_TEST_CHECK(notification);
 238   DALI_TEST_CHECK(notification2);
 239   END_TEST;
 240 }
 241
 242 int UtcDaliAddPropertyNotificationCallback(void)
 243 {
 244   TestApplication application; // Reset all test adapter return codes
 245
 246   TestClass* object = new TestClass(application.GetScene());
 247
 248   object->Initialize();
 249   application.Render(RENDER_FRAME_INTERVAL);
 250   application.SendNotification();
 251
 252   gCallBackCalled = false;
 253
 254   tet_infoline(" UtcDaliAddPropertyNotificationCallback - Forcing notification condition true, should receive a notification");
 255   object->mActor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
 256   application.Render(RENDER_FRAME_INTERVAL);
 257   application.SendNotification();
 258   application.Render(RENDER_FRAME_INTERVAL);
 259   application.SendNotification();
 260   DALI_TEST_CHECK(gCallBackCalled);
 261   gCallBackCalled = false;
 262
 263   tet_infoline(" UtcDaliAddPropertyNotificationCallback - Forcing notification condition false, should not receive a notification");
 264   object->mActor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
 265   application.Render(RENDER_FRAME_INTERVAL);
 266   application.SendNotification();
 267   application.Render(RENDER_FRAME_INTERVAL);
 268   application.SendNotification();
 269   DALI_TEST_CHECK(!gCallBackCalled);
 270   gCallBackCalled = false;
 271
 272   tet_infoline(" UtcDaliAddPropertyNotificationCallback - Deleting notification and it's owning object, should not receive a notification");
 273   object->mActor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
 274   application.Render(RENDER_FRAME_INTERVAL);
 275   application.SendNotification();
 276   object->Terminate();
 277   application.Render(RENDER_FRAME_INTERVAL);
 278   application.SendNotification();
 279   DALI_TEST_CHECK(!gCallBackCalled);
 280
 281   tet_infoline(" UtcDaliAddPropertyNotificationCallback - Removing notification and it's owning object, should not receive a notification");
 282   object->Initialize();
 283   application.Render(RENDER_FRAME_INTERVAL);
 284   application.SendNotification();
 285   gCallBackCalled = false;
 286
 287   object->RemovePropertyNotification();
 288
 289   object->mActor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
 290   application.Render(RENDER_FRAME_INTERVAL);
 291   application.SendNotification();
 292   application.Render(RENDER_FRAME_INTERVAL);
 293   application.SendNotification();
 294   DALI_TEST_CHECK(!gCallBackCalled);
 295
 296   tet_infoline(" UtcDaliAddPropertyNotificationCallback - Removing all notifications and it's owning object, should not receive a notification");
 297   object->Initialize();
 298   application.Render(RENDER_FRAME_INTERVAL);
 299   application.SendNotification();
 300   gCallBackCalled = false;
 301
 302   object->RemovePropertyNotifications();
 303
 304   object->mActor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
 305   application.Render(RENDER_FRAME_INTERVAL);
 306   application.SendNotification();
 307   application.Render(RENDER_FRAME_INTERVAL);
 308   application.SendNotification();
 309   DALI_TEST_CHECK(!gCallBackCalled);
 310
 311   delete object;
 312   END_TEST;
 313 }
 314
 315 int UtcDaliAddPropertyNotificationTypeProperty(void)
 316 {
 317   TestApplication application;
 318
 319   Actor actor = Actor::New();
 320
 321   // Currently, Type registry properties cannot be animated
 322   try
 323   {
 324     actor.AddPropertyNotification(PROPERTY_REGISTRATION_START_INDEX, GreaterThanCondition(100.0f));
 325   }
 326   catch(DaliException& e)
 327   {
 328     DALI_TEST_ASSERT(e, "Property notification added to event side only property", TEST_LOCATION);
 329   }
 330   END_TEST;
 331 }
 332
 333 int UtcDaliAddPropertyNotificationEventSidePropertyN(void)
 334 {
 335   TestApplication application;
 336
 337   Actor actor = Actor::New();
 338
 339   // Currently, Type registry properties cannot be animated
 340   try
 341   {
 342     actor.AddPropertyNotification(PROPERTY_REGISTRATION_MAX_INDEX - 1, GreaterThanCondition(100.0f));
 343   }
 344   catch(DaliException& e)
 345   {
 346     DALI_TEST_ASSERT(e, "Property notification added to event side only property", TEST_LOCATION);
 347   }
 348   END_TEST;
 349 }
 350
 351 int UtcDaliAddPropertyNotificationSize(void)
 352 {
 353   TestApplication application;
 354   tet_infoline(" UtcDaliAddPropertyNotificationSize");
 355
 356   Actor actor = Actor::New();
 357
 358   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::SIZE, StepCondition(1.0f, 1.0f));
 359   DALI_TEST_CHECK(notification);
 360   END_TEST;
 361 }
 362
 363 int UtcDaliPropertyNotificationGetCondition(void)
 364 {
 365   TestApplication application;
 366   tet_infoline(" UtcDaliPropertyNotificationGetCondition");
 367
 368   Actor actor = Actor::New();
 369
 370   PropertyCondition    condition    = GreaterThanCondition(100.0f);
 371   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, condition);
 372   DALI_TEST_CHECK(condition == notification.GetCondition());
 373   END_TEST;
 374 }
 375
 376 class PropertyNotificationConstWrapper
 377 {
 378 public:
 379   PropertyNotificationConstWrapper(PropertyNotification propertyNotification)
 380   : mPropertyNotification(propertyNotification)
 381   {
 382   }
 383
 384   /**
 385    * Returns const reference to property notification.
 386    * @return const reference.
 387    */
 388   const PropertyCondition& GetCondition() const
 389   {
 390     return mPropertyNotification.GetCondition();
 391   }
 392
 393   PropertyNotification mPropertyNotification;
 394 };
 395
 396 int UtcDaliPropertyNotificationGetConditionConst(void)
 397 {
 398   TestApplication application;
 399   tet_infoline(" UtcDaliPropertyNotificationGetConditionConst");
 400
 401   Actor actor = Actor::New();
 402
 403   PropertyCondition                condition    = GreaterThanCondition(100.0f);
 404   PropertyNotification             notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, condition);
 405   PropertyNotificationConstWrapper notificationConst(notification);
 406   const PropertyCondition&         conditionReference1 = notificationConst.GetCondition();
 407   const PropertyCondition&         conditionReference2 = notificationConst.GetCondition();
 408
 409   DALI_TEST_CHECK((&conditionReference1) == (&conditionReference2));
 410   DALI_TEST_CHECK(conditionReference1 == condition);
 411   END_TEST;
 412 }
 413
 414 int UtcDaliPropertyNotificationGetTarget(void)
 415 {
 416   TestApplication application;
 417   tet_infoline(" UtcDaliPropertyNotificationGetTarget");
 418
 419   Actor actor  = Actor::New();
 420   Actor actor2 = Actor::New();
 421
 422   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X,
 423                                                                     GreaterThanCondition(100.0f));
 424   Actor                targetActor  = Actor::DownCast(notification.GetTarget());
 425
 426   DALI_TEST_CHECK(targetActor == actor);
 427   END_TEST;
 428 }
 429
 430 int UtcDaliPropertyNotificationGetProperty(void)
 431 {
 432   TestApplication application;
 433   tet_infoline(" UtcDaliPropertyNotificationGetProperty");
 434
 435   Actor actor = Actor::New();
 436
 437   PropertyNotification notification   = actor.AddPropertyNotification(Actor::Property::POSITION_X,
 438                                                                     GreaterThanCondition(100.0f));
 439   Property::Index      targetProperty = notification.GetTargetProperty();
 440
 441   DALI_TEST_EQUALS(targetProperty, (Property::Index)Actor::Property::POSITION_X, TEST_LOCATION);
 442   END_TEST;
 443 }
 444
 445 int UtcDaliPropertyNotificationGetNotifyMode(void)
 446 {
 447   TestApplication application;
 448   tet_infoline(" UtcDaliPropertyNotificationGetNotifyMode");
 449
 450   Actor actor = Actor::New();
 451
 452   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X,
 453                                                                     GreaterThanCondition(100.0f));
 454   notification.SetNotifyMode(PropertyNotification::NOTIFY_ON_CHANGED);
 455   PropertyNotification::NotifyMode notifyMode = notification.GetNotifyMode();
 456
 457   DALI_TEST_EQUALS(notifyMode, PropertyNotification::NOTIFY_ON_CHANGED, TEST_LOCATION);
 458   END_TEST;
 459 }
 460
 461 int UtcDaliPropertyNotificationGetNotifyResultP(void)
 462 {
 463   TestApplication application;
 464   tet_infoline(" UtcDaliPropertyNotificationGetNotifyMode");
 465
 466   Actor actor = Actor::New();
 467
 468   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X,
 469                                                                     GreaterThanCondition(100.0f));
 470   notification.SetNotifyMode(PropertyNotification::NOTIFY_ON_CHANGED);
 471   gCallBackCalled = false;
 472   notification.NotifySignal().Connect(&TestCallback);
 473
 474   actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
 475
 476   application.Render(RENDER_FRAME_INTERVAL);
 477   application.SendNotification();
 478   application.Render(RENDER_FRAME_INTERVAL);
 479   application.SendNotification();
 480
 481   bool notifyResult = notification.GetNotifyResult();
 482
 483   DALI_TEST_EQUALS(notifyResult, false, TEST_LOCATION);
 484
 485   END_TEST;
 486 }
 487
 488 int UtcDaliPropertyNotificationGreaterThan(void)
 489 {
 490   TestApplication application;
 491   tet_infoline(" UtcDaliPropertyNotificationGreaterThan");
 492
 493   Actor actor = Actor::New();
 494   application.GetScene().Add(actor);
 495
 496   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(100.0f));
 497   notification.NotifySignal().Connect(&TestCallback);
 498
 499   actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
 500   Wait(application, DEFAULT_WAIT_PERIOD);
 501
 502   // Move right to satisfy condition
 503   gCallBackCalled = false;
 504   actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
 505   Wait(application, DEFAULT_WAIT_PERIOD);
 506   DALI_TEST_CHECK(gCallBackCalled);
 507
 508   // Move left to un-satisfy condition
 509   gCallBackCalled = false;
 510   actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
 511   Wait(application, DEFAULT_WAIT_PERIOD);
 512   DALI_TEST_CHECK(!gCallBackCalled);
 513
 514   // Move right to satisfy condition again.
 515   gCallBackCalled = false;
 516   Wait(application, DEFAULT_WAIT_PERIOD);
 517   actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
 518   Wait(application, DEFAULT_WAIT_PERIOD);
 519   DALI_TEST_CHECK(gCallBackCalled);
 520   END_TEST;
 521 }
 522
 523 int UtcDaliPropertyNotificationLessThan(void)
 524 {
 525   TestApplication application;
 526   tet_infoline(" UtcDaliPropertyNotificationLessThan");
 527
 528   Actor actor = Actor::New();
 529   application.GetScene().Add(actor);
 530
 531   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, LessThanCondition(100.0f));
 532   notification.NotifySignal().Connect(&TestCallback);
 533
 534   actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
 535   Wait(application, DEFAULT_WAIT_PERIOD);
 536
 537   // Move left to satisfy condition
 538   gCallBackCalled = false;
 539   actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
 540   Wait(application, DEFAULT_WAIT_PERIOD);
 541   DALI_TEST_CHECK(gCallBackCalled);
 542
 543   // Move right to un-satisfy condition
 544   gCallBackCalled = false;
 545   actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
 546   Wait(application, DEFAULT_WAIT_PERIOD);
 547   DALI_TEST_CHECK(!gCallBackCalled);
 548
 549   // Move left to satisfy condition again.
 550   gCallBackCalled = false;
 551   Wait(application, DEFAULT_WAIT_PERIOD);
 552   actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
 553   Wait(application, DEFAULT_WAIT_PERIOD);
 554   DALI_TEST_CHECK(gCallBackCalled);
 555   END_TEST;
 556 }
 557
 558 int UtcDaliPropertyNotificationInside(void)
 559 {
 560   TestApplication application;
 561   tet_infoline(" UtcDaliPropertyNotificationInside");
 562
 563   Actor actor = Actor::New();
 564   application.GetScene().Add(actor);
 565
 566   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, InsideCondition(100.0f, 200.0f));
 567   notification.NotifySignal().Connect(&TestCallback);
 568
 569   actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
 570   Wait(application, DEFAULT_WAIT_PERIOD);
 571
 572   // Move inside to satisfy condition
 573   gCallBackCalled = false;
 574   actor.SetProperty(Actor::Property::POSITION, Vector3(150.0f, 0.0f, 0.0f));
 575   Wait(application, DEFAULT_WAIT_PERIOD);
 576   DALI_TEST_CHECK(gCallBackCalled);
 577
 578   // Move outside (right) to un-satisfy condition
 579   gCallBackCalled = false;
 580   actor.SetProperty(Actor::Property::POSITION, Vector3(300.0f, 0.0f, 0.0f));
 581   Wait(application, DEFAULT_WAIT_PERIOD);
 582   DALI_TEST_CHECK(!gCallBackCalled);
 583
 584   // Move inside to satisfy condition again.
 585   gCallBackCalled = false;
 586   Wait(application, DEFAULT_WAIT_PERIOD);
 587   actor.SetProperty(Actor::Property::POSITION, Vector3(150.0f, 0.0f, 0.0f));
 588   Wait(application, DEFAULT_WAIT_PERIOD);
 589   DALI_TEST_CHECK(gCallBackCalled);
 590   END_TEST;
 591 }
 592
 593 int UtcDaliPropertyNotificationOutside(void)
 594 {
 595   TestApplication application;
 596   tet_infoline(" UtcDaliPropertyNotificationOutside");
 597
 598   Actor actor = Actor::New();
 599   application.GetScene().Add(actor);
 600
 601   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, OutsideCondition(100.0f, 200.0f));
 602   notification.NotifySignal().Connect(&TestCallback);
 603
 604   actor.SetProperty(Actor::Property::POSITION, Vector3(150.0f, 0.0f, 0.0f));
 605   Wait(application, DEFAULT_WAIT_PERIOD);
 606
 607   // Move outside (left) to satisfy condition
 608   gCallBackCalled = false;
 609   actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
 610   Wait(application, DEFAULT_WAIT_PERIOD);
 611   DALI_TEST_CHECK(gCallBackCalled);
 612
 613   // Move inside to un-satisfy condition
 614   gCallBackCalled = false;
 615   actor.SetProperty(Actor::Property::POSITION, Vector3(150.0f, 0.0f, 0.0f));
 616   Wait(application, DEFAULT_WAIT_PERIOD);
 617   DALI_TEST_CHECK(!gCallBackCalled);
 618
 619   // Move outside (right) to satisfy condition again.
 620   gCallBackCalled = false;
 621   Wait(application, DEFAULT_WAIT_PERIOD);
 622   actor.SetProperty(Actor::Property::POSITION, Vector3(300.0f, 0.0f, 0.0f));
 623   Wait(application, DEFAULT_WAIT_PERIOD);
 624   DALI_TEST_CHECK(gCallBackCalled);
 625   END_TEST;
 626 }
 627
 628 int UtcDaliPropertyNotificationVectorComponentGreaterThan(void)
 629 {
 630   TestApplication application;
 631   tet_infoline(" UtcDaliPropertyNotificationGreaterThan");
 632
 633   Actor actor = Actor::New();
 634   application.GetScene().Add(actor);
 635
 636   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION, 0, GreaterThanCondition(100.0f));
 637   notification.NotifySignal().Connect(&TestCallback);
 638   notification = actor.AddPropertyNotification(Actor::Property::POSITION, 1, GreaterThanCondition(100.0f));
 639   notification.NotifySignal().Connect(&TestCallback);
 640   notification = actor.AddPropertyNotification(Actor::Property::POSITION, 2, GreaterThanCondition(100.0f));
 641   notification.NotifySignal().Connect(&TestCallback);
 642   notification = actor.AddPropertyNotification(Actor::Property::COLOR, 3, GreaterThanCondition(0.5f));
 643   notification.NotifySignal().Connect(&TestCallback);
 644
 645   actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
 646   actor.SetProperty(Actor::Property::COLOR, Vector4(0.0f, 0.0f, 0.0f, 0.0f));
 647   Wait(application, DEFAULT_WAIT_PERIOD);
 648
 649   // Move right to satisfy XAxis condition
 650   gCallBackCalled = false;
 651   actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
 652   Wait(application, DEFAULT_WAIT_PERIOD);
 653   DALI_TEST_CHECK(gCallBackCalled);
 654
 655   // Move down to satisfy YAxis condition
 656   gCallBackCalled = false;
 657   actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 200.0f, 0.0f));
 658   Wait(application, DEFAULT_WAIT_PERIOD);
 659   DALI_TEST_CHECK(gCallBackCalled);
 660
 661   // Move forward to satisfy ZAxis
 662   gCallBackCalled = false;
 663   Wait(application, DEFAULT_WAIT_PERIOD);
 664   actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 200.0f, 200.0f));
 665   Wait(application, DEFAULT_WAIT_PERIOD);
 666   DALI_TEST_CHECK(gCallBackCalled);
 667
 668   // Change alpha Colour to satisfy w/alpha component condition
 669   gCallBackCalled = false;
 670   Wait(application, DEFAULT_WAIT_PERIOD);
 671   actor.SetProperty(Actor::Property::COLOR, Vector4(0.0f, 0.0f, 0.0f, 1.0f));
 672   Wait(application, DEFAULT_WAIT_PERIOD);
 673   DALI_TEST_CHECK(gCallBackCalled);
 674   END_TEST;
 675 }
 676
 677 int UtcDaliPropertyNotificationVectorComponentLessThan(void)
 678 {
 679   TestApplication application;
 680   tet_infoline(" UtcDaliPropertyNotificationLessThan");
 681
 682   Actor actor = Actor::New();
 683   application.GetScene().Add(actor);
 684
 685   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION, 0, LessThanCondition(-100.0f));
 686   notification.NotifySignal().Connect(&TestCallback);
 687   notification = actor.AddPropertyNotification(Actor::Property::POSITION, 1, LessThanCondition(-100.0f));
 688   notification.NotifySignal().Connect(&TestCallback);
 689   notification = actor.AddPropertyNotification(Actor::Property::POSITION, 2, LessThanCondition(-100.0f));
 690   notification.NotifySignal().Connect(&TestCallback);
 691   notification = actor.AddPropertyNotification(Actor::Property::COLOR, 3, LessThanCondition(0.5f));
 692   notification.NotifySignal().Connect(&TestCallback);
 693
 694   actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
 695   actor.SetProperty(Actor::Property::COLOR, Vector4(0.0f, 0.0f, 0.0f, 1.0f));
 696   Wait(application, DEFAULT_WAIT_PERIOD);
 697
 698   // Move left to satisfy XAxis condition
 699   gCallBackCalled = false;
 700   actor.SetProperty(Actor::Property::POSITION, Vector3(-200.0f, 0.0f, 0.0f));
 701   Wait(application, DEFAULT_WAIT_PERIOD);
 702   DALI_TEST_CHECK(gCallBackCalled);
 703
 704   // Move up to satisfy YAxis condition
 705   gCallBackCalled = false;
 706   actor.SetProperty(Actor::Property::POSITION, Vector3(-200.0f, -200.0f, 0.0f));
 707   Wait(application, DEFAULT_WAIT_PERIOD);
 708   DALI_TEST_CHECK(gCallBackCalled);
 709
 710   // Move back to satisfy ZAxis
 711   gCallBackCalled = false;
 712   Wait(application, DEFAULT_WAIT_PERIOD);
 713   actor.SetProperty(Actor::Property::POSITION, Vector3(-200.0f, -200.0f, -200.0f));
 714   Wait(application, DEFAULT_WAIT_PERIOD);
 715   DALI_TEST_CHECK(gCallBackCalled);
 716
 717   // Change alpha Colour to satisfy w/alpha component condition
 718   gCallBackCalled = false;
 719   Wait(application, DEFAULT_WAIT_PERIOD);
 720   actor.SetProperty(Actor::Property::COLOR, Vector4(0.0f, 0.0f, 0.0f, 0.0f));
 721   Wait(application, DEFAULT_WAIT_PERIOD);
 722   DALI_TEST_CHECK(gCallBackCalled);
 723   END_TEST;
 724 }
 725
 726 int UtcDaliPropertyNotificationVectorComponentInside(void)
 727 {
 728   TestApplication application;
 729   tet_infoline(" UtcDaliPropertyNotificationInside");
 730
 731   Actor actor = Actor::New();
 732   application.GetScene().Add(actor);
 733
 734   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION, 0, InsideCondition(-100.0f, 100.0f));
 735   notification.NotifySignal().Connect(&TestCallback);
 736   notification = actor.AddPropertyNotification(Actor::Property::POSITION, 1, InsideCondition(-100.0f, 100.0f));
 737   notification.NotifySignal().Connect(&TestCallback);
 738   notification = actor.AddPropertyNotification(Actor::Property::POSITION, 2, InsideCondition(-100.0f, 100.0f));
 739   notification.NotifySignal().Connect(&TestCallback);
 740   notification = actor.AddPropertyNotification(Actor::Property::COLOR, 3, InsideCondition(0.25f, 0.75f));
 741   notification.NotifySignal().Connect(&TestCallback);
 742
 743   // set outside all conditions
 744   actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 200.0f, 200.0f));
 745   actor.SetProperty(Actor::Property::COLOR, Vector4(0.0f, 0.0f, 0.0f, 1.0f));
 746   Wait(application, DEFAULT_WAIT_PERIOD);
 747
 748   // Move x to inside condition
 749   gCallBackCalled = false;
 750   actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 200.0f, 200.0f));
 751   Wait(application, DEFAULT_WAIT_PERIOD);
 752   DALI_TEST_CHECK(gCallBackCalled);
 753
 754   // Move y to inside condition
 755   gCallBackCalled = false;
 756   actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 200.0f));
 757   Wait(application, DEFAULT_WAIT_PERIOD);
 758   DALI_TEST_CHECK(gCallBackCalled);
 759
 760   // Move z to inside condition
 761   gCallBackCalled = false;
 762   Wait(application, DEFAULT_WAIT_PERIOD);
 763   actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
 764   Wait(application, DEFAULT_WAIT_PERIOD);
 765   DALI_TEST_CHECK(gCallBackCalled);
 766
 767   // change alpha to inside condition
 768   gCallBackCalled = false;
 769   Wait(application, DEFAULT_WAIT_PERIOD);
 770   actor.SetProperty(Actor::Property::COLOR, Vector4(0.0f, 0.0f, 0.0f, 0.5f));
 771   Wait(application, DEFAULT_WAIT_PERIOD);
 772   DALI_TEST_CHECK(gCallBackCalled);
 773   END_TEST;
 774 }
 775
 776 int UtcDaliPropertyNotificationVectorComponentOutside(void)
 777 {
 778   TestApplication application;
 779   tet_infoline(" UtcDaliPropertyNotificationOutside");
 780
 781   Actor actor = Actor::New();
 782   application.GetScene().Add(actor);
 783
 784   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION, 0, OutsideCondition(-100.0f, 100.0f));
 785   notification.NotifySignal().Connect(&TestCallback);
 786   notification = actor.AddPropertyNotification(Actor::Property::POSITION, 1, OutsideCondition(-100.0f, 100.0f));
 787   notification.NotifySignal().Connect(&TestCallback);
 788   notification = actor.AddPropertyNotification(Actor::Property::POSITION, 2, OutsideCondition(-100.0f, 100.0f));
 789   notification.NotifySignal().Connect(&TestCallback);
 790   notification = actor.AddPropertyNotification(Actor::Property::COLOR, 3, OutsideCondition(0.25f, 0.75f));
 791   notification.NotifySignal().Connect(&TestCallback);
 792
 793   // set inside all conditions
 794   actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
 795   actor.SetProperty(Actor::Property::COLOR, Vector4(0.0f, 0.0f, 0.0f, 0.5f));
 796   Wait(application, DEFAULT_WAIT_PERIOD);
 797
 798   // Move x to outside condition
 799   gCallBackCalled = false;
 800   actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
 801   Wait(application, DEFAULT_WAIT_PERIOD);
 802   DALI_TEST_CHECK(gCallBackCalled);
 803
 804   // Move y to outside condition
 805   gCallBackCalled = false;
 806   actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 200.0f, 0.0f));
 807   Wait(application, DEFAULT_WAIT_PERIOD);
 808   DALI_TEST_CHECK(gCallBackCalled);
 809
 810   // Move z to outside condition
 811   gCallBackCalled = false;
 812   Wait(application, DEFAULT_WAIT_PERIOD);
 813   actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 200.0f, 200.0f));
 814   Wait(application, DEFAULT_WAIT_PERIOD);
 815   DALI_TEST_CHECK(gCallBackCalled);
 816
 817   // change alpha to outside condition
 818   gCallBackCalled = false;
 819   Wait(application, DEFAULT_WAIT_PERIOD);
 820   actor.SetProperty(Actor::Property::COLOR, Vector4(0.0f, 0.0f, 0.0f, 1.0f));
 821   Wait(application, DEFAULT_WAIT_PERIOD);
 822   DALI_TEST_CHECK(gCallBackCalled);
 823   END_TEST;
 824 }
 825
 826 int UtcDaliPropertyNotificationSetSizeResultP(void)
 827 {
 828   TestApplication application;
 829   bool            notifyResult;
 830   tet_infoline(" UtcDaliPropertyNotificationSetSizeResultP");
 831
 832   Actor actor = Actor::New();
 833
 834   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::SIZE, StepCondition(1.0f, 1.0f));
 835   notification.SetNotifyMode(PropertyNotification::NOTIFY_ON_CHANGED);
 836   gCallBackCalled = false;
 837   notification.NotifySignal().Connect(&TestCallback);
 838
 839   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
 840
 841   application.Render(RENDER_FRAME_INTERVAL);
 842   application.SendNotification();
 843   application.Render(RENDER_FRAME_INTERVAL);
 844   application.SendNotification();
 845
 846   notifyResult = notification.GetNotifyResult();
 847
 848   DALI_TEST_EQUALS(notifyResult, true, TEST_LOCATION);
 849
 850   gCallBackCalled = false;
 851
 852   actor.SetProperty(Actor::Property::SIZE, Vector2(200.0f, 200.0f));
 853
 854   application.Render(RENDER_FRAME_INTERVAL);
 855   application.SendNotification();
 856   application.Render(RENDER_FRAME_INTERVAL);
 857   application.SendNotification();
 858
 859   notifyResult = notification.GetNotifyResult();
 860
 861   DALI_TEST_EQUALS(notifyResult, true, TEST_LOCATION);
 862
 863   END_TEST;
 864 }
 865
 866 int UtcDaliPropertyConditionGetArguments(void)
 867 {
 868   TestApplication application;
 869   tet_infoline(" UtcDaliPropertyConditionGetArguments");
 870
 871   PropertyCondition condition = GreaterThanCondition(50.0f);
 872
 873   DALI_TEST_EQUALS(condition.GetArgumentCount(), 1u, TEST_LOCATION);
 874   float value = condition.GetArgument(0);
 875   DALI_TEST_EQUALS(value, 50.0f, TEST_LOCATION);
 876
 877   condition = InsideCondition(125.0f, 250.0f);
 878
 879   DALI_TEST_EQUALS(condition.GetArgumentCount(), 2u, TEST_LOCATION);
 880   float value1 = condition.GetArgument(0);
 881   float value2 = condition.GetArgument(1);
 882   DALI_TEST_EQUALS(value1, 125.0f, TEST_LOCATION);
 883   DALI_TEST_EQUALS(value2, 250.0f, TEST_LOCATION);
 884   END_TEST;
 885 }
 886
 887 int UtcDaliPropertyNotificationStepVector4(void)
 888 {
 889   TestApplication application;
 890   tet_infoline(" UtcDaliPropertyNotificationStepVector4");
 891
 892   Actor actor = Actor::New();
 893   application.GetScene().Add(actor);
 894
 895   const float step      = 10.0f;
 896   float       initValue = 5.0f;
 897
 898   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::COLOR, StepCondition(step * 2, 0.0f));
 899   notification.NotifySignal().Connect(&TestCallback);
 900
 901   actor.SetProperty(Actor::Property::COLOR, Vector4(initValue, 0.0f, 0.0f, 0.0f));
 902   Wait(application, DEFAULT_WAIT_PERIOD);
 903
 904   // test both directions
 905   for(int i = 1; i < 10;)
 906   {
 907     // Move x to positive
 908     gCallBackCalled = false;
 909     actor.SetProperty(Actor::Property::COLOR, Vector4(initValue + (i++ * step), 0.0f, 0.0f, 0.0f));
 910     Wait(application, DEFAULT_WAIT_PERIOD);
 911     DALI_TEST_CHECK(!gCallBackCalled);
 912
 913     actor.SetProperty(Actor::Property::COLOR, Vector4(initValue + (i++ * step), 0.0f, 0.0f, 0.0f));
 914     Wait(application, DEFAULT_WAIT_PERIOD);
 915     DALI_TEST_CHECK(gCallBackCalled);
 916   }
 917
 918   initValue = -5.0f;
 919   actor.SetProperty(Actor::Property::COLOR, Vector4(initValue, 0.0f, 0.0f, 0.0f));
 920   Wait(application, DEFAULT_WAIT_PERIOD);
 921
 922   for(int i = 1; i < 10;)
 923   {
 924     // Move x to negative
 925     gCallBackCalled = false;
 926     actor.SetProperty(Actor::Property::COLOR, Vector4(initValue - (i++ * step), 0.0f, 0.0f, 0.0f));
 927     Wait(application, DEFAULT_WAIT_PERIOD);
 928     DALI_TEST_CHECK(!gCallBackCalled);
 929
 930     actor.SetProperty(Actor::Property::COLOR, Vector4(initValue - (i++ * step), 0.0f, 0.0f, 0.0f));
 931     Wait(application, DEFAULT_WAIT_PERIOD);
 932     DALI_TEST_CHECK(gCallBackCalled);
 933   }
 934   END_TEST;
 935 }
 936
 937 int UtcDaliPropertyNotificationStepFloat(void)
 938 {
 939   TestApplication application;
 940   tet_infoline(" UtcDaliPropertyNotificationStepFloat");
 941
 942   Actor actor = Actor::New();
 943   application.GetScene().Add(actor);
 944
 945   const float step      = 10.0f;
 946   float       initValue = 5.0f;
 947
 948   // float
 949   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION, 0, StepCondition(step * 2, 0.0f));
 950   notification.NotifySignal().Connect(&TestCallback);
 951
 952   // set initial position
 953   actor.SetProperty(Actor::Property::POSITION, Vector3(initValue, 0.0f, 0.0f));
 954   Wait(application, DEFAULT_WAIT_PERIOD);
 955
 956   // test both directions
 957   for(int i = 1; i < 10;)
 958   {
 959     // Move x to positive
 960     gCallBackCalled = false;
 961     actor.SetProperty(Actor::Property::POSITION, Vector3(initValue + (i++ * step), 0.0f, 0.0f));
 962     Wait(application, DEFAULT_WAIT_PERIOD);
 963     DALI_TEST_CHECK(!gCallBackCalled);
 964
 965     actor.SetProperty(Actor::Property::POSITION, Vector3(initValue + (i++ * step), 0.0f, 0.0f));
 966     Wait(application, DEFAULT_WAIT_PERIOD);
 967     DALI_TEST_CHECK(gCallBackCalled);
 968   }
 969
 970   initValue = -5.0f;
 971   actor.SetProperty(Actor::Property::POSITION, Vector3(initValue, 0.0f, 0.0f));
 972   Wait(application, DEFAULT_WAIT_PERIOD);
 973
 974   for(int i = 1; i < 10;)
 975   {
 976     // Move x to negative
 977     gCallBackCalled = false;
 978     actor.SetProperty(Actor::Property::POSITION, Vector3(initValue - (i++ * step), 0.0f, 0.0f));
 979     Wait(application, DEFAULT_WAIT_PERIOD);
 980     DALI_TEST_CHECK(!gCallBackCalled);
 981
 982     actor.SetProperty(Actor::Property::POSITION, Vector3(initValue - (i++ * step), 0.0f, 0.0f));
 983     Wait(application, DEFAULT_WAIT_PERIOD);
 984     DALI_TEST_CHECK(gCallBackCalled);
 985   }
 986   END_TEST;
 987 }
 988
 989 int UtcDaliPropertyNotificationStepVector2(void)
 990 {
 991   TestApplication application;
 992   tet_infoline(" UtcDaliPropertyNotificationStepVector2");
 993
 994   Actor actor = Actor::New();
 995   application.GetScene().Add(actor);
 996
 997   const float step      = 10.0f;
 998   float       initValue = 5.0f;
 999
1000   Property::Index propertyIndex = actor.RegisterProperty("testProperty", Vector2::ZERO);
1001
1002   PropertyNotification notification = actor.AddPropertyNotification(propertyIndex, StepCondition(step * 2, 0.0f));
1003   notification.NotifySignal().Connect(&TestCallback);
1004
1005   actor.SetProperty(propertyIndex, Vector2(initValue, 0.0f));
1006   Wait(application, DEFAULT_WAIT_PERIOD);
1007
1008   // test both directions
1009   for(int i = 1; i < 10;)
1010   {
1011     // Move x to positive
1012     gCallBackCalled = false;
1013     actor.SetProperty(propertyIndex, Vector2(initValue + (i++ * step), 0.0f));
1014     Wait(application, DEFAULT_WAIT_PERIOD);
1015     DALI_TEST_CHECK(!gCallBackCalled);
1016
1017     actor.SetProperty(propertyIndex, Vector2(initValue + (i++ * step), 0.0f));
1018     Wait(application, DEFAULT_WAIT_PERIOD);
1019     DALI_TEST_CHECK(gCallBackCalled);
1020   }
1021
1022   initValue = -5.0f;
1023   actor.SetProperty(propertyIndex, Vector2(initValue, 0.0f));
1024   Wait(application, DEFAULT_WAIT_PERIOD);
1025
1026   for(int i = 1; i < 10;)
1027   {
1028     // Move x to negative
1029     gCallBackCalled = false;
1030     actor.SetProperty(propertyIndex, Vector2(initValue - (i++ * step), 0.0f));
1031     Wait(application, DEFAULT_WAIT_PERIOD);
1032     DALI_TEST_CHECK(!gCallBackCalled);
1033
1034     actor.SetProperty(propertyIndex, Vector2(initValue - (i++ * step), 0.0f));
1035     Wait(application, DEFAULT_WAIT_PERIOD);
1036     DALI_TEST_CHECK(gCallBackCalled);
1037   }
1038   END_TEST;
1039 }
1040
1041 int UtcDaliPropertyNotificationStepVector3(void)
1042 {
1043   TestApplication application;
1044   tet_infoline(" UtcDaliPropertyNotificationStepVector3");
1045
1046   Actor actor = Actor::New();
1047   application.GetScene().Add(actor);
1048
1049   const float step      = 10.0f;
1050   float       initValue = 5.0f;
1051
1052   // float
1053   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION, StepCondition(step * 2, 0.0f));
1054   notification.NotifySignal().Connect(&TestCallback);
1055
1056   // set initial position
1057   actor.SetProperty(Actor::Property::POSITION, Vector3(initValue, 0.0f, 0.0f));
1058   Wait(application, DEFAULT_WAIT_PERIOD);
1059
1060   // test both directions
1061   for(int i = 1; i < 10;)
1062   {
1063     // Move x to positive position
1064     gCallBackCalled = false;
1065     actor.SetProperty(Actor::Property::POSITION, Vector3(initValue + (i++ * step), 0.0f, 0.0f));
1066     Wait(application, DEFAULT_WAIT_PERIOD);
1067     DALI_TEST_CHECK(!gCallBackCalled);
1068
1069     actor.SetProperty(Actor::Property::POSITION, Vector3(initValue + (i++ * step), 0.0f, 0.0f));
1070     Wait(application, DEFAULT_WAIT_PERIOD);
1071     DALI_TEST_CHECK(gCallBackCalled);
1072   }
1073
1074   initValue = -5.0f;
1075   actor.SetProperty(Actor::Property::POSITION, Vector3(initValue, 0.0f, 0.0f));
1076   Wait(application, DEFAULT_WAIT_PERIOD);
1077
1078   for(int i = 1; i < 10;)
1079   {
1080     // Move x to negative position
1081     gCallBackCalled = false;
1082     actor.SetProperty(Actor::Property::POSITION, Vector3(initValue - (i++ * step), 0.0f, 0.0f));
1083     Wait(application, DEFAULT_WAIT_PERIOD);
1084     DALI_TEST_CHECK(!gCallBackCalled);
1085
1086     actor.SetProperty(Actor::Property::POSITION, Vector3(initValue - (i++ * step), 0.0f, 0.0f));
1087     Wait(application, DEFAULT_WAIT_PERIOD);
1088     DALI_TEST_CHECK(gCallBackCalled);
1089   }
1090   END_TEST;
1091 }
1092
1093 int UtcDaliPropertyNotificationVariableStep(void)
1094 {
1095   TestApplication application;
1096   tet_infoline(" UtcDaliPropertyNotificationStep");
1097
1098   Actor actor = Actor::New();
1099   application.GetScene().Add(actor);
1100
1101   Dali::Vector<float> values;
1102
1103   const float averageStep = 100.0f;
1104
1105   for(int i = 1; i < 10; i++)
1106   {
1107     values.PushBack(i * averageStep + (i % 2 == 0 ? -(averageStep * 0.2f) : (averageStep * 0.2f)));
1108   }
1109   // float
1110   PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION, 0, VariableStepCondition(values));
1111   notification.NotifySignal().Connect(&TestCallback);
1112
1113   // set initial position lower than first position in list
1114   actor.SetProperty(Actor::Property::POSITION, Vector3(values[0] - averageStep, 0.0f, 0.0f));
1115   Wait(application, DEFAULT_WAIT_PERIOD);
1116
1117   for(unsigned int i = 0; i < values.Count() - 1; ++i)
1118   {
1119     gCallBackCalled = false;
1120     // set position half way between the current values
1121     float position = values[i] + (0.5f * (values[i + 1] - values[i]));
1122     actor.SetProperty(Actor::Property::POSITION, Vector3(position, 0.0f, 0.0f));
1123     Wait(application, DEFAULT_WAIT_PERIOD);
1124     DALI_TEST_CHECK(gCallBackCalled);
1125   }
1126   END_TEST;
1127 }
1128
1129 static bool gCallBack2Called = false;
1130 void        TestCallback2(PropertyNotification& source)
1131 {
1132   gCallBack2Called = true;
1133 }
1134
1135 int UtcDaliPropertyNotificationOrder(void)
1136 {
1137   TestApplication application; // Reset all test adapter return codes
1138
1139   Actor actor = Actor::New();
1140   application.GetScene().Add(actor);
1141   // this should complete in first frame
1142   PropertyNotification notification1 = actor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(90.0f));
1143   notification1.NotifySignal().Connect(&TestCallback);
1144   // this should complete in second frame
1145   PropertyNotification notification2 = actor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(150.0f));
1146   notification2.NotifySignal().Connect(&TestCallback2);
1147   Animation animation = Animation::New(0.032f); // finishes in 32 ms
1148   animation.AnimateTo(Property(actor, Actor::Property::POSITION), Vector3(200.0f, 0.0f, 0.0f), AlphaFunction::LINEAR);
1149   animation.Play();
1150
1151   // flush the queue
1152   application.SendNotification();
1153   // first frame
1154   application.Render(RENDER_FRAME_INTERVAL);
1155   // no notifications yet
1156   DALI_TEST_EQUALS(gCallBackCalled, false, TEST_LOCATION);
1157   DALI_TEST_EQUALS(gCallBack2Called, false, TEST_LOCATION);
1158   gCallBackCalled  = false;
1159   gCallBack2Called = false;
1160
1161   // dont serve the notifications but run another update & render
1162   // this simulates situation where there is a notification in event side but it's not been picked up by event thread
1163   // second frame
1164   application.Render(RENDER_FRAME_INTERVAL);
1165   DALI_TEST_EQUALS(gCallBackCalled, false, TEST_LOCATION);
1166   DALI_TEST_EQUALS(gCallBack2Called, false, TEST_LOCATION);
1167
1168   // serve the notifications
1169   application.SendNotification();
1170   DALI_TEST_EQUALS(gCallBackCalled, true, TEST_LOCATION);
1171   DALI_TEST_EQUALS(gCallBack2Called, true, TEST_LOCATION);
1172
1173   gCallBackCalled  = false;
1174   gCallBack2Called = false;
1175   application.Render(RENDER_FRAME_INTERVAL);
1176   application.SendNotification();
1177   DALI_TEST_EQUALS(gCallBackCalled, false, TEST_LOCATION);
1178   DALI_TEST_EQUALS(gCallBack2Called, false, TEST_LOCATION);
1179
1180   END_TEST;
1181 }
1182
1183 int UtcDaliPropertyConditionGetArgumentNegative(void)
1184 {
1185   TestApplication         application;
1186   Dali::PropertyCondition instance;
1187   instance.Reset();
1188   try
1189   {
1190     unsigned long arg1(0u);
1191     instance.GetArgument(arg1);
1192     DALI_TEST_CHECK(false); // Should not get here
1193   }
1194   catch(...)
1195   {
1196     DALI_TEST_CHECK(true); // We expect an assert
1197   }
1198   END_TEST;
1199 }
1200
1201 int UtcDaliPropertyConditionGetArgumentCountNegative(void)
1202 {
1203   TestApplication         application;
1204   Dali::PropertyCondition instance;
1205   instance.Reset();
1206   try
1207   {
1208     instance.GetArgumentCount();
1209     DALI_TEST_CHECK(false); // Should not get here
1210   }
1211   catch(...)
1212   {
1213     DALI_TEST_CHECK(true); // We expect an assert
1214   }
1215   END_TEST;
1216 }