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   Any value2 = 0.f;
 121
 122   value2 = 9.f; // Test operator=( const Type& ).
 123
 124   value2.Get( fValue );
 125
 126   DALI_TEST_EQUALS( fValue, 9.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 127
 128   Any value3 = 5.f;
 129
 130   value1 = value3; // Test operator=( const Any& ).
 131
 132   value1.Get( fValue );
 133
 134   DALI_TEST_EQUALS( fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 135
 136   Any value4;
 137
 138   value4 = value3; // Test operator=( const Any& ) when current object is not initialized.
 139
 140   value4.Get( fValue );
 141
 142   DALI_TEST_EQUALS( fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 143
 144   // Test assign a value to value3 doesn't modify value1.
 145   value3 = 3.f;
 146
 147   value1.Get( fValue );
 148
 149   DALI_TEST_EQUALS( fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 150
 151   value3.Get( fValue );
 152
 153   DALI_TEST_EQUALS( fValue, 3.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 154
 155   // Test the branch when copying the same object.
 156   Any value5 = 3.f;
 157   Any& value6( value5 );
 158
 159   value6 = value5;
 160
 161   value6.Get( fValue );
 162   DALI_TEST_EQUALS( fValue, 3.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 163   END_TEST;
 164 }
 165
 166 int UtcDaliAnyNegativeAssignmentOperators(void)
 167 {
 168   TestApplication application;
 169
 170   tet_infoline("Test assignment operators.");
 171
 172   Any value1 = 4.f;
 173   Any value2 = 5u;
 174
 175   bool assert = false;
 176
 177   try
 178   {
 179     value1 = value2; // Test operator=( const Any& );
 180   }
 181   catch( Dali::DaliException& e )
 182   {
 183     tet_printf( "Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str() );
 184     assert = true;
 185   }
 186
 187   if( assert )
 188   {
 189     tet_result( TET_PASS );
 190   }
 191   else
 192   {
 193     tet_result( TET_FAIL );
 194   }
 195   END_TEST;
 196 }
 197
 198 int UtcDaliAnyGetType(void)
 199 {
 200   TestApplication application;
 201
 202   tet_infoline("Test GetType().");
 203
 204   Any value;
 205
 206   DALI_TEST_CHECK( typeid( void ) == value.GetType() );
 207
 208   value = 5.f;
 209
 210   DALI_TEST_CHECK( typeid( float ) == value.GetType() );
 211   END_TEST;
 212 }
 213
 214 int UtcDaliAnyGet(void)
 215 {
 216   TestApplication application;
 217
 218   tet_infoline("Test Get().");
 219
 220   Any value1( 5.f );
 221
 222   float fValue = value1.Get<float>();
 223
 224   DALI_TEST_EQUALS( fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 225
 226   fValue = 0.f;
 227   value1.Get( fValue );
 228   DALI_TEST_EQUALS( fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 229
 230   class MyClass
 231   {
 232   public:
 233     MyClass( float fValue, int iValue )
 234     : mAny( MyStruct( fValue, iValue ) )
 235     {
 236     }
 237
 238     const MyStruct& Get() const
 239     {
 240       return AnyCastReference<MyStruct>( mAny );
 241     }
 242
 243     MyStruct* GetPointer()
 244     {
 245       return AnyCast<MyStruct>( &mAny );
 246     }
 247
 248     const MyStruct* GetPointer() const
 249     {
 250       return AnyCast<MyStruct>( &mAny );
 251     }
 252
 253   private:
 254     Dali::Any mAny;
 255   };
 256
 257   MyClass myClass( 3.25f, 3 );
 258
 259   MyStruct myStruct1 = myClass.Get();
 260   const MyStruct& myStruct2 = myClass.Get();
 261   MyStruct* myStruct3 = myClass.GetPointer();
 262   const MyStruct* myStruct4 = myClass.GetPointer();
 263
 264   DALI_TEST_EQUALS( myStruct1.mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 265   DALI_TEST_EQUALS( myStruct2.mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 266   DALI_TEST_EQUALS( myStruct3->mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 267   DALI_TEST_EQUALS( myStruct4->mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 268   DALI_TEST_EQUALS( myStruct1.mIntValue, 3, TEST_LOCATION );
 269   DALI_TEST_EQUALS( myStruct2.mIntValue, 3, TEST_LOCATION );
 270   DALI_TEST_EQUALS( myStruct3->mIntValue, 3, TEST_LOCATION );
 271   DALI_TEST_EQUALS( myStruct4->mIntValue, 3, TEST_LOCATION );
 272
 273   END_TEST;
 274 }
 275
 276 int UtcDaliAnyNegativeGet(void)
 277 {
 278   TestApplication application;
 279   tet_infoline("Test Get().");
 280
 281   Any value1;
 282   Any value2( 5.f );
 283
 284   bool assert1 = false;
 285   bool assert2 = false;
 286
 287   unsigned int uiValue = 0u;
 288
 289   try
 290   {
 291     uiValue = value1.Get< unsigned int >();
 292   }
 293
 294   catch( Dali::DaliException& e )
 295   {
 296     tet_printf( "Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str() );
 297     assert1 = true;
 298   }
 299
 300   try
 301   {
 302     uiValue = value2.Get< unsigned int >();
 303   }
 304
 305   catch( Dali::DaliException& e )
 306   {
 307     tet_printf( "Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str() );
 308     assert2 = true;
 309   }
 310
 311   if( assert1 && assert2 )
 312   {
 313     tet_result( TET_PASS );
 314   }
 315   else
 316   {
 317     tet_result( TET_FAIL );
 318   }
 319   uiValue++;  // supresss warning from unused variable
 320   END_TEST;
 321 }