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

   1 /*
   2  * Copyright (c) 2014 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 // Temp include
  25 #include <dali/public-api/object/any.h>
  26
  27 namespace
  28 {
  29 static int gRefCount;
  30 struct MyStruct
  31 {
  32   MyStruct()
  33   : mFloatValue(0.f),
  34     mIntValue(0)
  35   {
  36     ++gRefCount;
  37   }
  38
  39   MyStruct(float fValue, int iValue)
  40   : mFloatValue(fValue),
  41     mIntValue(iValue)
  42   {
  43     ++gRefCount;
  44   }
  45
  46   MyStruct(const MyStruct& myStruct)
  47   : mFloatValue(myStruct.mFloatValue),
  48     mIntValue(myStruct.mIntValue)
  49   {
  50     ++gRefCount;
  51   }
  52
  53   ~MyStruct()
  54   {
  55     --gRefCount;
  56   }
  57
  58   MyStruct& operator=(const MyStruct& myStruct)
  59   {
  60     mFloatValue = myStruct.mFloatValue;
  61     mIntValue   = myStruct.mIntValue;
  62
  63     return *this;
  64   }
  65
  66   float mFloatValue;
  67   int   mIntValue;
  68 };
  69 } // namespace
  70
  71 using namespace Dali;
  72
  73 void utc_dali_any_startup(void)
  74 {
  75   test_return_value = TET_UNDEF;
  76 }
  77
  78 void utc_dali_any_cleanup(void)
  79 {
  80   test_return_value = TET_PASS;
  81 }
  82
  83 int UtcDaliAnyConstructors(void)
  84 {
  85   TestApplication application;
  86
  87   tet_infoline("Test Any constructors.");
  88
  89   gRefCount = 0;
  90
  91   // Test default constructor.
  92   Any value;
  93
  94   DALI_TEST_CHECK(typeid(void) == value.GetType());
  95
  96   // Test constructor Any( const Type& )
  97   Any value1 = 4u;
  98
  99   // Test constructor Any( const Any& )
 100   Any value2 = value1;
 101
 102   // Test constructor Any( const Any& ) with a non initialized Any
 103   Any value3 = value;
 104
 105   // Test constructor Any( Any&& ) with a non initialized Any
 106   Any value4(Any(MyStruct(1.0f, 2)));
 107
 108   DALI_TEST_CHECK(typeid(unsigned int) == value1.GetType());
 109   DALI_TEST_CHECK(typeid(unsigned int) == value2.GetType());
 110   DALI_TEST_CHECK(typeid(void) == value3.GetType());
 111   DALI_TEST_CHECK(typeid(MyStruct) == value4.GetType());
 112   DALI_TEST_CHECK(gRefCount == 1);
 113
 114   // Test std::move operation result.
 115   Any value5(std::move(value4));
 116
 117   DALI_TEST_CHECK(value4.Empty());
 118   DALI_TEST_CHECK(typeid(MyStruct) == value5.GetType());
 119   DALI_TEST_CHECK(gRefCount == 1);
 120
 121   unsigned int uiValue1 = 0u;
 122   unsigned int uiValue2 = 0u;
 123   value1.Get(uiValue1);
 124   value2.Get(uiValue2);
 125
 126   DALI_TEST_EQUALS(uiValue1, uiValue2, TEST_LOCATION);
 127
 128   MyStruct myValue;
 129   value5.Get(myValue);
 130
 131   DALI_TEST_EQUALS(myValue.mFloatValue, 1.0f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 132   DALI_TEST_EQUALS(myValue.mIntValue, 2, TEST_LOCATION);
 133
 134   END_TEST;
 135 }
 136
 137 int UtcDaliAnyAssignmentOperators(void)
 138 {
 139   TestApplication application;
 140
 141   tet_infoline("Test assignment operators.");
 142
 143   float fValue = 0.f;
 144
 145   Any value1;
 146
 147   value1 = 4.f; // Test operator=( const Type& ) when current object is not initialized.
 148
 149   value1.Get(fValue);
 150
 151   DALI_TEST_EQUALS(fValue, 4.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 152
 153   value1 = 9.f; // Test operator=( const Type& ).
 154
 155   value1.Get(fValue);
 156
 157   DALI_TEST_EQUALS(fValue, 9.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 158
 159   Any value3 = 5.f;
 160
 161   value1 = value3; // Test operator=( const Any& ).
 162
 163   value1.Get(fValue);
 164
 165   DALI_TEST_EQUALS(fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 166
 167   Any value4;
 168
 169   value4 = value3; // Test operator=( const Any& ) when current object is not initialized.
 170
 171   value4.Get(fValue);
 172
 173   DALI_TEST_EQUALS(fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 174
 175   // Test assign a value to value3 doesn't modify value1.
 176   value3 = 3.f;
 177
 178   value1.Get(fValue);
 179
 180   DALI_TEST_EQUALS(fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 181
 182   value3.Get(fValue);
 183
 184   DALI_TEST_EQUALS(fValue, 3.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 185
 186   // Test the branch when copying the same object.
 187   Any  value5 = 3.f;
 188   Any& value6(value5);
 189
 190   value6 = value5;
 191
 192   value6.Get(fValue);
 193   DALI_TEST_EQUALS(fValue, 3.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 194
 195   // test assignment for non-empty Any = empty Any
 196   Any value7;
 197   value6 = value7;
 198   DALI_TEST_CHECK(value6.Empty());
 199
 200   // Due to value6 is reference of value5, value5 also become empty
 201   DALI_TEST_CHECK(value5.Empty());
 202
 203   gRefCount = 0;
 204
 205   // Do something to above compiler optimize out
 206   Any value8 = value3;
 207
 208   DALI_TEST_CHECK(typeid(float) == value8.GetType());
 209
 210   // Test operator=( Any&& ).
 211   value8 = Any(MyStruct(3.0f, 4));
 212
 213   DALI_TEST_CHECK(typeid(MyStruct) == value8.GetType());
 214   DALI_TEST_CHECK(gRefCount == 1);
 215
 216   // Do something to above compiler optimize out
 217   Any value9 = value3;
 218
 219   DALI_TEST_CHECK(typeid(float) == value9.GetType());
 220
 221   // Test std::move operation result.
 222   value9 = std::move(value8);
 223
 224   DALI_TEST_CHECK(value8.Empty());
 225   DALI_TEST_CHECK(typeid(MyStruct) == value9.GetType());
 226   DALI_TEST_CHECK(gRefCount == 1);
 227
 228   MyStruct myValue;
 229   value9.Get(myValue);
 230
 231   DALI_TEST_EQUALS(myValue.mFloatValue, 3.0f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 232   DALI_TEST_EQUALS(myValue.mIntValue, 4, TEST_LOCATION);
 233
 234   END_TEST;
 235 }
 236
 237 int UtcDaliAnyNegativeAssignmentOperators(void)
 238 {
 239   TestApplication application;
 240
 241   tet_infoline("Test assignment operators.");
 242
 243   Any value1 = 4.f;
 244   Any value2 = 5u;
 245
 246   bool assert = false;
 247
 248   try
 249   {
 250     value1 = value2; // Test operator=( const Any& );
 251   }
 252   catch(Dali::DaliException& e)
 253   {
 254     DALI_TEST_PRINT_ASSERT(e);
 255     assert = true;
 256   }
 257
 258   if(assert)
 259   {
 260     tet_result(TET_PASS);
 261   }
 262   else
 263   {
 264     tet_result(TET_FAIL);
 265   }
 266   END_TEST;
 267 }
 268
 269 int UtcDaliAnyGetType(void)
 270 {
 271   TestApplication application;
 272
 273   tet_infoline("Test GetType().");
 274
 275   Any value;
 276
 277   DALI_TEST_CHECK(typeid(void) == value.GetType());
 278
 279   value = 5.f;
 280
 281   DALI_TEST_CHECK(typeid(float) == value.GetType());
 282   END_TEST;
 283 }
 284
 285 int UtcDaliAnyGet(void)
 286 {
 287   TestApplication application;
 288
 289   tet_infoline("Test Get().");
 290
 291   Any value1(5.f);
 292
 293   float fValue = value1.Get<float>();
 294
 295   DALI_TEST_EQUALS(fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 296
 297   fValue = 0.f;
 298   value1.Get(fValue);
 299   DALI_TEST_EQUALS(fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 300
 301   class MyClass
 302   {
 303   public:
 304     MyClass(float fValue, int iValue)
 305     : mAny(MyStruct(fValue, iValue))
 306     {
 307     }
 308
 309     const MyStruct& Get() const
 310     {
 311       return AnyCastReference<MyStruct>(mAny);
 312     }
 313
 314     MyStruct* GetPointer()
 315     {
 316       return AnyCast<MyStruct>(&mAny);
 317     }
 318
 319     const MyStruct* GetPointer() const
 320     {
 321       return AnyCast<MyStruct>(&mAny);
 322     }
 323
 324   private:
 325     Dali::Any mAny;
 326   };
 327
 328   MyClass myClass(3.25f, 3);
 329
 330   MyStruct        myStruct1 = myClass.Get();
 331   const MyStruct& myStruct2 = myClass.Get();
 332   MyStruct*       myStruct3 = myClass.GetPointer();
 333   const MyStruct* myStruct4 = myClass.GetPointer();
 334
 335   if(myStruct3 == NULL)
 336   {
 337     tet_result(TET_FAIL);
 338     END_TEST;
 339   }
 340
 341   if(myStruct4 == NULL)
 342   {
 343     tet_result(TET_FAIL);
 344     END_TEST;
 345   }
 346
 347   DALI_TEST_EQUALS(myStruct1.mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 348   DALI_TEST_EQUALS(myStruct2.mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 349   DALI_TEST_EQUALS(myStruct3->mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 350   DALI_TEST_EQUALS(myStruct4->mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 351   DALI_TEST_EQUALS(myStruct1.mIntValue, 3, TEST_LOCATION);
 352   DALI_TEST_EQUALS(myStruct2.mIntValue, 3, TEST_LOCATION);
 353   DALI_TEST_EQUALS(myStruct3->mIntValue, 3, TEST_LOCATION);
 354   DALI_TEST_EQUALS(myStruct4->mIntValue, 3, TEST_LOCATION);
 355
 356   // Test on empty any object
 357   Dali::Any myAny;
 358   float*    f = myAny.GetPointer<float>();
 359   DALI_TEST_CHECK(f == NULL);
 360
 361   // Test on getting wrong type
 362   myAny = 1.f;
 363   try
 364   {
 365     myAny.GetPointer<int>();
 366     tet_result(TET_FAIL);
 367   }
 368   catch(Dali::DaliException& e)
 369   {
 370     DALI_TEST_PRINT_ASSERT(e);
 371   }
 372
 373   END_TEST;
 374 }
 375
 376 int UtcDaliAnyNegativeGet(void)
 377 {
 378   TestApplication application;
 379   tet_infoline("Test Get().");
 380
 381   Any value1;
 382   Any value2(5.f);
 383
 384   bool assert1 = false;
 385   bool assert2 = false;
 386
 387   unsigned int uiValue = 0u;
 388
 389   try
 390   {
 391     uiValue = value1.Get<unsigned int>();
 392   }
 393
 394   catch(Dali::DaliException& e)
 395   {
 396     DALI_TEST_PRINT_ASSERT(e);
 397     assert1 = true;
 398   }
 399
 400   try
 401   {
 402     uiValue = value2.Get<unsigned int>();
 403   }
 404
 405   catch(Dali::DaliException& e)
 406   {
 407     DALI_TEST_PRINT_ASSERT(e);
 408     assert2 = true;
 409   }
 410
 411   if(assert1 && assert2)
 412   {
 413     tet_result(TET_PASS);
 414   }
 415   else
 416   {
 417     tet_result(TET_FAIL);
 418   }
 419   uiValue++; // supresss warning from unused variable
 420   END_TEST;
 421 }
 422
 423 int UtcDaliAnyReferenceCheck(void)
 424 {
 425   gRefCount = 0;
 426
 427   {
 428     Dali::Any any[10]; // Create local 10 empty Any
 429
 430     DALI_TEST_EQUALS(gRefCount, 0, TEST_LOCATION);
 431
 432     // Create [0 5)
 433     for(int i = 0; i < 5; i++)
 434     {
 435       any[i] = MyStruct(1.0f, i);
 436     }
 437     DALI_TEST_EQUALS(gRefCount, 5, TEST_LOCATION);
 438
 439     // Move from [0 5) to [5 10)
 440     for(int i = 0; i < 5; i++)
 441     {
 442       any[i + 5] = std::move(any[i]);
 443     }
 444     DALI_TEST_EQUALS(gRefCount, 5, TEST_LOCATION);
 445
 446     // Copy from [5 10) to [0 5)
 447     for(int i = 0; i < 5; i++)
 448     {
 449       any[i] = any[i + 5];
 450     }
 451     DALI_TEST_EQUALS(gRefCount, 10, TEST_LOCATION);
 452   }
 453
 454   // Check whether all Dali::Any are released
 455   DALI_TEST_EQUALS(gRefCount, 0, TEST_LOCATION);
 456
 457   END_TEST;
 458 }