automated-tests/src/dali/utc-Dali-WeakHandle.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
  21 using namespace Dali;
  22
  23 namespace
  24 {
  25 /*******************************************************************************
  26  *
  27  * Custom Actor
  28  *
  29  ******************************************************************************/
  30 namespace Impl
  31 {
  32 struct MyTestCustomActor : public CustomActorImpl
  33 {
  34   typedef Signal<void()>      SignalType;
  35   typedef Signal<void(float)> SignalTypeFloat;
  36
  37   MyTestCustomActor()
  38   : CustomActorImpl(ActorFlags())
  39   {
  40   }
  41
  42   virtual ~MyTestCustomActor()
  43   {
  44   }
  45
  46   void ResetCallStack()
  47   {
  48   }
  49
  50   // From CustomActorImpl
  51   virtual void OnSceneConnection(int depth)
  52   {
  53   }
  54   virtual void OnSceneDisconnection()
  55   {
  56   }
  57   virtual void OnChildAdd(Actor& child)
  58   {
  59   }
  60   virtual void OnChildRemove(Actor& child)
  61   {
  62   }
  63   virtual void OnSizeSet(const Vector3& targetSize)
  64   {
  65   }
  66   virtual void OnSizeAnimation(Animation& animation, const Vector3& targetSize)
  67   {
  68   }
  69   virtual void OnKeyInputFocusGained()
  70   {
  71   }
  72   virtual void OnKeyInputFocusLost()
  73   {
  74   }
  75   virtual Vector3 GetNaturalSize()
  76   {
  77     return Vector3(0.0f, 0.0f, 0.0f);
  78   }
  79
  80   virtual float GetHeightForWidth(float width)
  81   {
  82     return 0.0f;
  83   }
  84
  85   virtual float GetWidthForHeight(float height)
  86   {
  87     return 0.0f;
  88   }
  89
  90   virtual void OnRelayout(const Vector2& size, RelayoutContainer& container)
  91   {
  92   }
  93
  94   virtual void OnSetResizePolicy(ResizePolicy::Type policy, Dimension::Type dimension)
  95   {
  96   }
  97
  98   virtual void OnCalculateRelayoutSize(Dimension::Type dimension)
  99   {
 100   }
 101
 102   virtual float CalculateChildSize(const Dali::Actor& child, Dimension::Type dimension)
 103   {
 104     return 0.0f;
 105   }
 106
 107   virtual void OnLayoutNegotiated(float size, Dimension::Type dimension)
 108   {
 109   }
 110
 111   virtual bool RelayoutDependentOnChildren(Dimension::Type dimension = Dimension::ALL_DIMENSIONS)
 112   {
 113     return false;
 114   }
 115
 116 public:
 117   SignalType mSignal;
 118 };
 119
 120 }; // namespace Impl
 121
 122 class MyTestCustomActor : public CustomActor
 123 {
 124 public:
 125   typedef Signal<void()>      SignalType;
 126   typedef Signal<void(float)> SignalTypeFloat;
 127
 128   MyTestCustomActor()
 129   {
 130   }
 131
 132   static MyTestCustomActor New()
 133   {
 134     Impl::MyTestCustomActor* p = new Impl::MyTestCustomActor;
 135     return MyTestCustomActor(*p); // takes ownership
 136   }
 137
 138   virtual ~MyTestCustomActor()
 139   {
 140   }
 141
 142   static MyTestCustomActor DownCast(BaseHandle handle)
 143   {
 144     MyTestCustomActor result;
 145
 146     CustomActor custom = Dali::CustomActor::DownCast(handle);
 147     if(custom)
 148     {
 149       CustomActorImpl& customImpl = custom.GetImplementation();
 150
 151       Impl::MyTestCustomActor* impl = dynamic_cast<Impl::MyTestCustomActor*>(&customImpl);
 152
 153       if(impl)
 154       {
 155         result = MyTestCustomActor(customImpl.GetOwner());
 156       }
 157     }
 158
 159     return result;
 160   }
 161
 162   SignalType& GetCustomSignal()
 163   {
 164     Dali::RefObject& obj = GetImplementation();
 165     return static_cast<Impl::MyTestCustomActor&>(obj).mSignal;
 166   }
 167
 168   MyTestCustomActor(Internal::CustomActor* internal)
 169   : CustomActor(internal)
 170   {
 171   }
 172
 173   MyTestCustomActor(Impl::MyTestCustomActor& impl)
 174   : CustomActor(impl)
 175   {
 176   }
 177 };
 178
 179 } // namespace
 180
 181 int UtcDaliWeakHandleBaseConstructorVoid(void)
 182 {
 183   TestApplication application;
 184   tet_infoline("Testing Dali::WeakHandleBase::WeakHandleBase()");
 185
 186   WeakHandleBase object;
 187
 188   DALI_TEST_CHECK(!object.GetBaseHandle());
 189
 190   END_TEST;
 191 }
 192
 193 int UtcDaliWeakHandleBaseConstructorWithBaseHandle(void)
 194 {
 195   TestApplication application;
 196   tet_infoline("Testing Dali::WeakHandleBase::WeakHandleBase(BaseHandle)");
 197
 198   BaseHandle     emptyHandle;
 199   WeakHandleBase emptyObject(emptyHandle);
 200   DALI_TEST_CHECK(!emptyObject.GetBaseHandle());
 201
 202   Actor          actor = Actor::New();
 203   WeakHandleBase object(actor);
 204   DALI_TEST_CHECK(object.GetBaseHandle() == actor);
 205
 206   Animation      animation = Animation::New(1.0f);
 207   WeakHandleBase animationObject(animation);
 208   DALI_TEST_CHECK(animationObject.GetBaseHandle() == animation);
 209
 210   END_TEST;
 211 }
 212
 213 int UtcDaliWeakHandleBaseCopyConstructor(void)
 214 {
 215   TestApplication application;
 216   tet_infoline("Testing Dali::WeakHandleBase::WeakHandleBase(const WeakHandleBase&)");
 217
 218   Actor actor = Actor::New();
 219   DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
 220
 221   WeakHandleBase object(actor);
 222   DALI_TEST_CHECK(object.GetBaseHandle() == actor);
 223   DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
 224
 225   WeakHandleBase copy(object);
 226   DALI_TEST_CHECK(copy.GetBaseHandle() == actor);
 227   DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
 228
 229   END_TEST;
 230 }
 231
 232 int UtcDaliWeakHandleBaseAssignmentOperator(void)
 233 {
 234   TestApplication application;
 235   tet_infoline("Testing Dali::WeakHandleBase::operator=");
 236
 237   Actor actor = Actor::New();
 238   DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
 239
 240   WeakHandleBase object(actor);
 241   DALI_TEST_CHECK(object.GetBaseHandle() == actor);
 242   DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
 243
 244   WeakHandleBase copy = object;
 245   DALI_TEST_CHECK(copy.GetBaseHandle() == actor);
 246   DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
 247
 248   END_TEST;
 249 }
 250
 251 int UtcDaliWeakHandleBaseMoveConstructor(void)
 252 {
 253   TestApplication application;
 254
 255   Actor actor = Actor::New();
 256   DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
 257
 258   WeakHandleBase object(actor);
 259   DALI_TEST_CHECK(object.GetBaseHandle() == actor);
 260   DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
 261
 262   WeakHandleBase move = std::move(object);
 263   DALI_TEST_CHECK(move.GetBaseHandle() == actor);
 264   DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
 265   DALI_TEST_CHECK(!object.GetBaseHandle());                                   // object moved
 266
 267   END_TEST;
 268 }
 269
 270 int UtcDaliWeakHandleBaseMoveAssignment(void)
 271 {
 272   TestApplication application;
 273
 274   Actor actor = Actor::New();
 275   DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
 276
 277   WeakHandleBase object(actor);
 278   DALI_TEST_CHECK(object.GetBaseHandle() == actor);
 279   DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
 280
 281   WeakHandleBase move;
 282   move = std::move(object);
 283   DALI_TEST_CHECK(move.GetBaseHandle() == actor);
 284   DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
 285   DALI_TEST_CHECK(!object.GetBaseHandle());                                   // object moved
 286
 287   END_TEST;
 288 }
 289
 290 int UtcDaliWeakHandleBaseEqualityOperatorP(void)
 291 {
 292   TestApplication application;
 293   tet_infoline("Positive Test Dali::WeakHandleBase::operator==");
 294
 295   WeakHandleBase object;
 296   WeakHandleBase theSameObject;
 297   DALI_TEST_CHECK(object == theSameObject);
 298
 299   Actor actor = Actor::New();
 300
 301   object = WeakHandleBase(actor);
 302   DALI_TEST_CHECK(object.GetBaseHandle() == actor);
 303
 304   theSameObject = object;
 305   DALI_TEST_CHECK(theSameObject.GetBaseHandle() == actor);
 306   DALI_TEST_CHECK(object == theSameObject);
 307
 308   END_TEST;
 309 }
 310
 311 int UtcDaliWeakHandleBaseEqualityOperatorN(void)
 312 {
 313   TestApplication application;
 314   tet_infoline("Negative Test Dali::WeakHandleBase::operator==");
 315
 316   Actor actor = Actor::New();
 317
 318   WeakHandleBase object(actor);
 319   DALI_TEST_CHECK(object.GetBaseHandle() == actor);
 320
 321   Actor          differentActor = Actor::New();
 322   WeakHandleBase aDifferentWeakHandleBase(differentActor);
 323
 324   DALI_TEST_CHECK(!(object == aDifferentWeakHandleBase));
 325
 326   END_TEST;
 327 }
 328
 329 int UtcDaliWeakHandleBaseInequalityOperatorP(void)
 330 {
 331   TestApplication application;
 332   tet_infoline("Positive Test Dali::WeakHandleBase::operator!=");
 333
 334   Actor actor = Actor::New();
 335
 336   WeakHandleBase object(actor);
 337   DALI_TEST_CHECK(object.GetBaseHandle() == actor);
 338
 339   Actor          differentActor = Actor::New();
 340   WeakHandleBase aDifferentWeakHandleBase(differentActor);
 341
 342   DALI_TEST_CHECK(object != aDifferentWeakHandleBase);
 343   END_TEST;
 344 }
 345
 346 int UtcDaliWeakHandleBaseInequalityOperatorN(void)
 347 {
 348   TestApplication application;
 349   tet_infoline("Negative Test Dali::WeakHandleBase::operator!=");
 350
 351   Actor actor = Actor::New();
 352
 353   WeakHandleBase object(actor);
 354   DALI_TEST_CHECK(object.GetBaseHandle() == actor);
 355
 356   WeakHandleBase theSameWeakHandleBase = object;
 357
 358   DALI_TEST_CHECK(!(object != theSameWeakHandleBase));
 359   END_TEST;
 360 }
 361
 362 int UtcDaliWeakHandleBaseGetBaseHandle(void)
 363 {
 364   TestApplication application;
 365   tet_infoline("Testing Dali::WeakHandleBase::GetBaseHandle()");
 366
 367   Handle         emptyHandle;
 368   WeakHandleBase emptyObject(emptyHandle);
 369   DALI_TEST_CHECK(!emptyObject.GetBaseHandle());
 370
 371   Actor          actor = Actor::New();
 372   WeakHandleBase object(actor);
 373   DALI_TEST_CHECK(object.GetBaseHandle() == actor);
 374
 375   WeakHandleBase theSameObject = WeakHandleBase(actor);
 376   DALI_TEST_CHECK(object.GetBaseHandle() == theSameObject.GetBaseHandle());
 377
 378   Actor          differentActor = Actor::New();
 379   WeakHandleBase aDifferentWeakHandleBase(differentActor);
 380   DALI_TEST_CHECK(object.GetBaseHandle() != aDifferentWeakHandleBase.GetBaseHandle());
 381
 382   Animation      animation = Animation::New(1.0f);
 383   WeakHandleBase animationObject(animation);
 384   DALI_TEST_CHECK(animationObject.GetBaseHandle() == animation);
 385
 386   WeakHandleBase theSameAnimationObject = WeakHandleBase(animation);
 387   DALI_TEST_CHECK(animationObject.GetBaseHandle() == theSameAnimationObject.GetBaseHandle());
 388
 389   Animation      differentAnimation = Animation::New(1.0f);
 390   WeakHandleBase aDifferentAnimationObject(differentAnimation);
 391   DALI_TEST_CHECK(animationObject.GetBaseHandle() != aDifferentAnimationObject.GetBaseHandle());
 392
 393   END_TEST;
 394 }
 395
 396 int UtcDaliWeakHandleBaseReset(void)
 397 {
 398   TestApplication application;
 399   tet_infoline("Testing Daku::WeakHandleBase::Reset()");
 400
 401   Actor          actor = Actor::New();
 402   WeakHandleBase object(actor);
 403   DALI_TEST_CHECK(object.GetBaseHandle() == actor);
 404
 405   object.Reset();
 406
 407   DALI_TEST_CHECK(object == WeakHandleBase());
 408   DALI_TEST_CHECK(object.GetBaseHandle() == Handle());
 409
 410   END_TEST;
 411 }
 412
 413 int UtcDaliWeakHandleGetHandle(void)
 414 {
 415   TestApplication application;
 416   tet_infoline("Testing Dali::WeakHandle::GetHandle()");
 417
 418   Actor             actor = Actor::New();
 419   WeakHandle<Actor> object(actor);
 420   DALI_TEST_CHECK(object.GetHandle() == actor);
 421
 422   MyTestCustomActor             customActor = MyTestCustomActor::New();
 423   WeakHandle<MyTestCustomActor> customObject(customActor);
 424   DALI_TEST_CHECK(customObject.GetHandle() == customActor);
 425
 426   DALI_TEST_CHECK(object.GetHandle() != customObject.GetHandle());
 427
 428   Animation             animation = Animation::New(1.0f);
 429   WeakHandle<Animation> animationObject(animation);
 430   DALI_TEST_CHECK(animationObject.GetHandle() == animation);
 431
 432   animation.Reset();
 433   DALI_TEST_CHECK(animationObject.GetHandle() == Animation());
 434
 435   END_TEST;
 436 }
 437
 438 int UtcDaliWeakHandleMoveConstructor(void)
 439 {
 440   TestApplication application;
 441
 442   Actor actor = Actor::New();
 443   DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
 444
 445   WeakHandle<Actor> object(actor);
 446   DALI_TEST_CHECK(object.GetHandle() == actor);
 447   DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
 448
 449   WeakHandle<Actor> move = std::move(object);
 450   DALI_TEST_CHECK(move.GetHandle() == actor);
 451   DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
 452   DALI_TEST_CHECK(!object.GetHandle());                                       // object moved
 453
 454   END_TEST;
 455 }
 456
 457 int UtcDaliWeakHandleMoveAssignment(void)
 458 {
 459   TestApplication application;
 460
 461   Actor actor = Actor::New();
 462   DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
 463
 464   WeakHandle<Actor> object(actor);
 465   DALI_TEST_CHECK(object.GetHandle() == actor);
 466   DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
 467
 468   WeakHandle<Actor> move;
 469   move = std::move(object);
 470   DALI_TEST_CHECK(move.GetHandle() == actor);
 471   DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
 472   DALI_TEST_CHECK(!object.GetHandle());                                       // object moved
 473
 474   END_TEST;
 475 }