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

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