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
 164   // test assignment for  non-empty Any = empty Any
 165   Any value7;
 166   value6 = value7;
 167   DALI_TEST_CHECK( value6.Empty() );
 168
 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   DALI_TEST_EQUALS( myStruct1.mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 272   DALI_TEST_EQUALS( myStruct2.mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 273   DALI_TEST_EQUALS( myStruct3->mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 274   DALI_TEST_EQUALS( myStruct4->mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 275   DALI_TEST_EQUALS( myStruct1.mIntValue, 3, TEST_LOCATION );
 276   DALI_TEST_EQUALS( myStruct2.mIntValue, 3, TEST_LOCATION );
 277   DALI_TEST_EQUALS( myStruct3->mIntValue, 3, TEST_LOCATION );
 278   DALI_TEST_EQUALS( myStruct4->mIntValue, 3, TEST_LOCATION );
 279
 280   // Test on empty any object
 281   Dali::Any myAny;
 282   float* f = myAny.GetPointer<float>();
 283   DALI_TEST_CHECK( f == NULL );
 284
 285   // Test on getting wrong type
 286   myAny = 1.f;
 287   try
 288   {
 289     myAny.GetPointer<int>();
 290     tet_result( TET_FAIL );
 291   }
 292   catch( Dali::DaliException& e )
 293   {
 294     DALI_TEST_PRINT_ASSERT( e );
 295   }
 296
 297   END_TEST;
 298 }
 299
 300 int UtcDaliAnyNegativeGet(void)
 301 {
 302   TestApplication application;
 303   tet_infoline("Test Get().");
 304
 305   Any value1;
 306   Any value2( 5.f );
 307
 308   bool assert1 = false;
 309   bool assert2 = false;
 310
 311   unsigned int uiValue = 0u;
 312
 313   try
 314   {
 315     uiValue = value1.Get< unsigned int >();
 316   }
 317
 318   catch( Dali::DaliException& e )
 319   {
 320     DALI_TEST_PRINT_ASSERT( e );
 321     assert1 = true;
 322   }
 323
 324   try
 325   {
 326     uiValue = value2.Get< unsigned int >();
 327   }
 328
 329   catch( Dali::DaliException& e )
 330   {
 331     DALI_TEST_PRINT_ASSERT( e );
 332     assert2 = true;
 333   }
 334
 335   if( assert1 && assert2 )
 336   {
 337     tet_result( TET_PASS );
 338   }
 339   else
 340   {
 341     tet_result( TET_FAIL );
 342   }
 343   uiValue++;  // supresss warning from unused variable
 344   END_TEST;
 345 }