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 struct MyStruct
  30 {
  31   MyStruct()
  32   : mFloatValue(0.f),
  33     mIntValue(0)
  34   {
  35   }
  36
  37   MyStruct(float fValue, int iValue)
  38   : mFloatValue(fValue),
  39     mIntValue(iValue)
  40   {
  41   }
  42
  43   MyStruct(const MyStruct& myStruct)
  44   : mFloatValue(myStruct.mFloatValue),
  45     mIntValue(myStruct.mIntValue)
  46   {
  47   }
  48
  49   MyStruct& operator=(const MyStruct& myStruct)
  50   {
  51     mFloatValue = myStruct.mFloatValue;
  52     mIntValue   = myStruct.mIntValue;
  53
  54     return *this;
  55   }
  56
  57   float mFloatValue;
  58   int   mIntValue;
  59 };
  60 } // namespace
  61
  62 using namespace Dali;
  63
  64 void utc_dali_any_startup(void)
  65 {
  66   test_return_value = TET_UNDEF;
  67 }
  68
  69 void utc_dali_any_cleanup(void)
  70 {
  71   test_return_value = TET_PASS;
  72 }
  73
  74 int UtcDaliAnyConstructors(void)
  75 {
  76   TestApplication application;
  77
  78   tet_infoline("Test Any constructors.");
  79
  80   // Test default constructor.
  81   Any value;
  82
  83   DALI_TEST_CHECK(typeid(void) == value.GetType());
  84
  85   // Test constructor Any( const Type& )
  86   Any value1 = 4u;
  87
  88   // Test constructor Any( const Any& )
  89   Any value2 = value1;
  90
  91   // Test constructor Any( const Any& ) with a non initialized Any
  92   Any value3 = value;
  93
  94   DALI_TEST_CHECK(typeid(unsigned int) == value1.GetType());
  95   DALI_TEST_CHECK(typeid(unsigned int) == value2.GetType());
  96   DALI_TEST_CHECK(typeid(void) == value3.GetType());
  97
  98   unsigned int uiValue1 = 0u;
  99   unsigned int uiValue2 = 0u;
 100   value1.Get(uiValue1);
 101   value2.Get(uiValue2);
 102
 103   DALI_TEST_EQUALS(uiValue1, uiValue2, TEST_LOCATION);
 104   END_TEST;
 105 }
 106
 107 int UtcDaliAnyAssignmentOperators(void)
 108 {
 109   TestApplication application;
 110
 111   tet_infoline("Test assignment operators.");
 112
 113   float fValue = 0.f;
 114
 115   Any value1;
 116
 117   value1 = 4.f; // Test operator=( const Type& ) when current object is not initialized.
 118
 119   value1.Get(fValue);
 120
 121   DALI_TEST_EQUALS(fValue, 4.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 122
 123   value1 = 9.f; // Test operator=( const Type& ).
 124
 125   value1.Get(fValue);
 126
 127   DALI_TEST_EQUALS(fValue, 9.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 128
 129   Any value3 = 5.f;
 130
 131   value1 = value3; // Test operator=( const Any& ).
 132
 133   value1.Get(fValue);
 134
 135   DALI_TEST_EQUALS(fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 136
 137   Any value4;
 138
 139   value4 = value3; // Test operator=( const Any& ) when current object is not initialized.
 140
 141   value4.Get(fValue);
 142
 143   DALI_TEST_EQUALS(fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 144
 145   // Test assign a value to value3 doesn't modify value1.
 146   value3 = 3.f;
 147
 148   value1.Get(fValue);
 149
 150   DALI_TEST_EQUALS(fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 151
 152   value3.Get(fValue);
 153
 154   DALI_TEST_EQUALS(fValue, 3.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 155
 156   // Test the branch when copying the same object.
 157   Any  value5 = 3.f;
 158   Any& value6(value5);
 159
 160   value6 = value5;
 161
 162   value6.Get(fValue);
 163   DALI_TEST_EQUALS(fValue, 3.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 164
 165   // test assignment for  non-empty Any = empty Any
 166   Any value7;
 167   value6 = value7;
 168   DALI_TEST_CHECK(value6.Empty());
 169
 170   END_TEST;
 171 }
 172
 173 int UtcDaliAnyNegativeAssignmentOperators(void)
 174 {
 175   TestApplication application;
 176
 177   tet_infoline("Test assignment operators.");
 178
 179   Any value1 = 4.f;
 180   Any value2 = 5u;
 181
 182   bool assert = false;
 183
 184   try
 185   {
 186     value1 = value2; // Test operator=( const Any& );
 187   }
 188   catch(Dali::DaliException& e)
 189   {
 190     DALI_TEST_PRINT_ASSERT(e);
 191     assert = true;
 192   }
 193
 194   if(assert)
 195   {
 196     tet_result(TET_PASS);
 197   }
 198   else
 199   {
 200     tet_result(TET_FAIL);
 201   }
 202   END_TEST;
 203 }
 204
 205 int UtcDaliAnyGetType(void)
 206 {
 207   TestApplication application;
 208
 209   tet_infoline("Test GetType().");
 210
 211   Any value;
 212
 213   DALI_TEST_CHECK(typeid(void) == value.GetType());
 214
 215   value = 5.f;
 216
 217   DALI_TEST_CHECK(typeid(float) == value.GetType());
 218   END_TEST;
 219 }
 220
 221 int UtcDaliAnyGet(void)
 222 {
 223   TestApplication application;
 224
 225   tet_infoline("Test Get().");
 226
 227   Any value1(5.f);
 228
 229   float fValue = value1.Get<float>();
 230
 231   DALI_TEST_EQUALS(fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 232
 233   fValue = 0.f;
 234   value1.Get(fValue);
 235   DALI_TEST_EQUALS(fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 236
 237   class MyClass
 238   {
 239   public:
 240     MyClass(float fValue, int iValue)
 241     : mAny(MyStruct(fValue, iValue))
 242     {
 243     }
 244
 245     const MyStruct& Get() const
 246     {
 247       return AnyCastReference<MyStruct>(mAny);
 248     }
 249
 250     MyStruct* GetPointer()
 251     {
 252       return AnyCast<MyStruct>(&mAny);
 253     }
 254
 255     const MyStruct* GetPointer() const
 256     {
 257       return AnyCast<MyStruct>(&mAny);
 258     }
 259
 260   private:
 261     Dali::Any mAny;
 262   };
 263
 264   MyClass myClass(3.25f, 3);
 265
 266   MyStruct        myStruct1 = myClass.Get();
 267   const MyStruct& myStruct2 = myClass.Get();
 268   MyStruct*       myStruct3 = myClass.GetPointer();
 269   const MyStruct* myStruct4 = myClass.GetPointer();
 270
 271   if(myStruct3 == NULL)
 272   {
 273     tet_result(TET_FAIL);
 274     END_TEST;
 275   }
 276
 277   if(myStruct4 == NULL)
 278   {
 279     tet_result(TET_FAIL);
 280     END_TEST;
 281   }
 282
 283   DALI_TEST_EQUALS(myStruct1.mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 284   DALI_TEST_EQUALS(myStruct2.mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 285   DALI_TEST_EQUALS(myStruct3->mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 286   DALI_TEST_EQUALS(myStruct4->mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 287   DALI_TEST_EQUALS(myStruct1.mIntValue, 3, TEST_LOCATION);
 288   DALI_TEST_EQUALS(myStruct2.mIntValue, 3, TEST_LOCATION);
 289   DALI_TEST_EQUALS(myStruct3->mIntValue, 3, TEST_LOCATION);
 290   DALI_TEST_EQUALS(myStruct4->mIntValue, 3, TEST_LOCATION);
 291
 292   // Test on empty any object
 293   Dali::Any myAny;
 294   float*    f = myAny.GetPointer<float>();
 295   DALI_TEST_CHECK(f == NULL);
 296
 297   // Test on getting wrong type
 298   myAny = 1.f;
 299   try
 300   {
 301     myAny.GetPointer<int>();
 302     tet_result(TET_FAIL);
 303   }
 304   catch(Dali::DaliException& e)
 305   {
 306     DALI_TEST_PRINT_ASSERT(e);
 307   }
 308
 309   END_TEST;
 310 }
 311
 312 int UtcDaliAnyNegativeGet(void)
 313 {
 314   TestApplication application;
 315   tet_infoline("Test Get().");
 316
 317   Any value1;
 318   Any value2(5.f);
 319
 320   bool assert1 = false;
 321   bool assert2 = false;
 322
 323   unsigned int uiValue = 0u;
 324
 325   try
 326   {
 327     uiValue = value1.Get<unsigned int>();
 328   }
 329
 330   catch(Dali::DaliException& e)
 331   {
 332     DALI_TEST_PRINT_ASSERT(e);
 333     assert1 = true;
 334   }
 335
 336   try
 337   {
 338     uiValue = value2.Get<unsigned int>();
 339   }
 340
 341   catch(Dali::DaliException& e)
 342   {
 343     DALI_TEST_PRINT_ASSERT(e);
 344     assert2 = true;
 345   }
 346
 347   if(assert1 && assert2)
 348   {
 349     tet_result(TET_PASS);
 350   }
 351   else
 352   {
 353     tet_result(TET_FAIL);
 354   }
 355   uiValue++; // supresss warning from unused variable
 356   END_TEST;
 357 }