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