automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.h

   1 #ifndef __DALI_TEST_SUITE_UTILS_H__
   2 #define __DALI_TEST_SUITE_UTILS_H__
   3
   4 /*
   5  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // EXTERNAL INCLUDES
  22 #include <cstdarg>
  23 #include <iostream>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali/public-api/dali-core.h>
  27
  28 void tet_infoline(const char*str);
  29 void tet_printf(const char *format, ...);
  30
  31 #include "test-application.h"
  32 #include "test-actor-utils.h"
  33
  34 using namespace Dali;
  35
  36 #define STRINGIZE_I(text) #text
  37 #define STRINGIZE(text) STRINGIZE_I(text)
  38
  39 // the following is the other compilers way of token pasting, gcc seems to just concatenate strings automatically
  40 //#define TOKENPASTE(x,y) x ## y
  41 #define TOKENPASTE(x,y) x y
  42 #define TOKENPASTE2(x,y) TOKENPASTE( x, y )
  43 #define TEST_LOCATION TOKENPASTE2( "Test failed in ", TOKENPASTE2( __FILE__, TOKENPASTE2( ", line ", STRINGIZE(__LINE__) ) ) )
  44
  45 #define TET_UNDEF 2
  46 #define TET_FAIL 1
  47 #define TET_PASS 0
  48
  49 extern int test_return_value;
  50
  51 void tet_result(int value);
  52
  53 #define END_TEST \
  54   return ((test_return_value>0)?1:0)
  55
  56 void tet_infoline(const char* str);
  57 void tet_printf(const char *format, ...);
  58
  59 /**
  60  * DALI_TEST_CHECK is a wrapper for tet_result.
  61  * If the condition evaluates to false, the test is stopped.
  62  * @param[in] The boolean expression to check
  63  */
  64 #define DALI_TEST_CHECK(condition)                                                        \
  65 if ( (condition) )                                                                        \
  66 {                                                                                         \
  67   tet_result(TET_PASS);                                                                   \
  68 }                                                                                         \
  69 else                                                                                      \
  70 {                                                                                         \
  71   fprintf(stderr, "%s Failed in %s at line %d\n", __PRETTY_FUNCTION__, __FILE__, __LINE__);    \
  72   tet_result(TET_FAIL);                                                                   \
  73   throw("TET_FAIL");                                                                      \
  74 }
  75
  76 template <typename Type>
  77 inline bool CompareType(Type value1, Type value2, float epsilon);
  78
  79 /**
  80  * A helper for fuzzy-comparing Vector2 objects
  81  * @param[in] vector1 the first object
  82  * @param[in] vector2 the second object
  83  * @param[in] epsilon difference threshold
  84  * @returns true if difference is smaller than epsilon threshold, false otherwise
  85  */
  86 template <>
  87 inline bool CompareType<float>(float value1, float value2, float epsilon)
  88 {
  89   return fabsf(value1 - value2) < epsilon;
  90 }
  91
  92 /**
  93  * A helper for fuzzy-comparing Vector2 objects
  94  * @param[in] vector1 the first object
  95  * @param[in] vector2 the second object
  96  * @param[in] epsilon difference threshold
  97  * @returns true if difference is smaller than epsilon threshold, false otherwise
  98  */
  99 template <>
 100 inline bool CompareType<Vector2>(Vector2 vector1, Vector2 vector2, float epsilon)
 101 {
 102   return fabsf(vector1.x - vector2.x)<epsilon && fabsf(vector1.y - vector2.y)<epsilon;
 103 }
 104
 105 /**
 106  * A helper for fuzzy-comparing Vector3 objects
 107  * @param[in] vector1 the first object
 108  * @param[in] vector2 the second object
 109  * @param[in] epsilon difference threshold
 110  * @returns true if difference is smaller than epsilon threshold, false otherwise
 111  */
 112 template <>
 113 inline bool CompareType<Vector3>(Vector3 vector1, Vector3 vector2, float epsilon)
 114 {
 115   return fabsf(vector1.x - vector2.x)<epsilon &&
 116          fabsf(vector1.y - vector2.y)<epsilon &&
 117          fabsf(vector1.z - vector2.z)<epsilon;
 118 }
 119
 120
 121 /**
 122  * A helper for fuzzy-comparing Vector4 objects
 123  * @param[in] vector1 the first object
 124  * @param[in] vector2 the second object
 125  * @param[in] epsilon difference threshold
 126  * @returns true if difference is smaller than epsilon threshold, false otherwise
 127  */
 128 template <>
 129 inline bool CompareType<Vector4>(Vector4 vector1, Vector4 vector2, float epsilon)
 130 {
 131   return fabsf(vector1.x - vector2.x)<epsilon &&
 132          fabsf(vector1.y - vector2.y)<epsilon &&
 133          fabsf(vector1.z - vector2.z)<epsilon &&
 134          fabsf(vector1.w - vector2.w)<epsilon;
 135 }
 136
 137 template <>
 138 inline bool CompareType<Quaternion>(Quaternion q1, Quaternion q2, float epsilon)
 139 {
 140   Quaternion q2N = -q2; // These quaternions represent the same rotation
 141   return CompareType<Vector4>(q1.mVector, q2.mVector, epsilon) || CompareType<Vector4>(q1.mVector, q2N.mVector, epsilon);
 142 }
 143
 144 template <>
 145 inline bool CompareType<Radian>(Radian q1, Radian q2, float epsilon)
 146 {
 147   return CompareType<float>(q1.radian, q2.radian, epsilon);
 148 }
 149
 150 template <>
 151 inline bool CompareType<Degree>(Degree q1, Degree q2, float epsilon)
 152 {
 153   return CompareType<float>(q1.degree, q2.degree, epsilon);
 154 }
 155
 156 template <>
 157 inline bool CompareType<Property::Value>(Property::Value q1, Property::Value q2, float epsilon)
 158 {
 159   Property::Type type = q1.GetType();
 160   if( type != q2.GetType() )
 161   {
 162     return false;
 163   }
 164
 165   switch(type)
 166   {
 167     case Property::BOOLEAN:
 168     {
 169       bool a, b;
 170       q1.Get(a);
 171       q2.Get(b);
 172       return a == b;
 173       break;
 174     }
 175     case Property::INTEGER:
 176     {
 177       int a, b;
 178       q1.Get(a);
 179       q2.Get(b);
 180       return a == b;
 181       break;
 182     }
 183     case Property::FLOAT:
 184     {
 185       float a, b;
 186       q1.Get(a);
 187       q2.Get(b);
 188       return CompareType<float>(a, b, epsilon);
 189       break;
 190     }
 191     case Property::VECTOR2:
 192     {
 193       Vector2 a, b;
 194       q1.Get(a);
 195       q2.Get(b);
 196       return CompareType<Vector2>(a, b, epsilon);
 197       break;
 198     }
 199     case Property::VECTOR3:
 200     {
 201       Vector3 a, b;
 202       q1.Get(a);
 203       q2.Get(b);
 204       return CompareType<Vector3>(a, b, epsilon);
 205       break;
 206     }
 207     case Property::RECTANGLE:
 208     case Property::VECTOR4:
 209     {
 210       Vector4 a, b;
 211       q1.Get(a);
 212       q2.Get(b);
 213       return CompareType<Vector4>(a, b, epsilon);
 214       break;
 215     }
 216     case Property::ROTATION:
 217     {
 218       Quaternion a, b;
 219       q1.Get(a);
 220       q2.Get(b);
 221       return CompareType<Quaternion>(a, b, epsilon);
 222       break;
 223     }
 224     default:
 225       return false;
 226   }
 227
 228   return false;
 229 }
 230
 231
 232 bool operator==(TimePeriod a, TimePeriod b);
 233 std::ostream& operator<<( std::ostream& ostream, TimePeriod value );
 234 std::ostream& operator<<( std::ostream& ostream, Radian angle );
 235 std::ostream& operator<<( std::ostream& ostream, Degree angle );
 236
 237 /**
 238  * Test whether two values are equal.
 239  * @param[in] value1 The first value
 240  * @param[in] value2 The second value
 241  * @param[in] location The TEST_LOCATION macro should be used here
 242  */
 243 template<typename Type>
 244 inline void DALI_TEST_EQUALS(Type value1, Type value2, const char* location)
 245 {
 246   if (!(value1 == value2))
 247   {
 248     std::ostringstream o;
 249     o << value1 << " == " << value2 << std::endl;
 250     fprintf(stderr, "%s, checking %s", location, o.str().c_str());
 251     tet_result(TET_FAIL);
 252   }
 253   else
 254   {
 255     tet_result(TET_PASS);
 256   }
 257 }
 258
 259 template<typename Type>
 260 inline void DALI_TEST_EQUALS(Type value1, Type value2, float epsilon, const char* location)
 261 {
 262   if( !CompareType<Type>(value1, value2, epsilon) )
 263   {
 264     std::ostringstream o;
 265     o << value1 << " == " << value2 << std::endl;
 266     fprintf(stderr, "%s, checking %s", location, o.str().c_str());
 267     tet_result(TET_FAIL);
 268   }
 269   else
 270   {
 271     tet_result(TET_PASS);
 272   }
 273 }
 274
 275 template<typename Type>
 276 inline void DALI_TEST_NOT_EQUALS(Type value1, Type value2, float epsilon, const char* location)
 277 {
 278   if( CompareType<Type>(value1, value2, epsilon) )
 279   {
 280     std::ostringstream o;
 281     o << value1 << " !=  " << value2 << std::endl;
 282     fprintf(stderr, "%s, checking %s", location, o.str().c_str());
 283     tet_result(TET_FAIL);
 284   }
 285   else
 286   {
 287     tet_result(TET_PASS);
 288   }
 289 }
 290
 291
 292 /**
 293  * Test whether two TimePeriods are within a certain distance of each other.
 294  * @param[in] value1 The first value
 295  * @param[in] value2 The second value
 296  * @param[in] epsilon The values must be within this distance of each other
 297  * @param[in] location The TEST_LOCATION macro should be used here
 298  */
 299 template<>
 300 inline void DALI_TEST_EQUALS<TimePeriod>( TimePeriod value1, TimePeriod value2, float epsilon, const char* location)
 301 {
 302   if ((fabs(value1.durationSeconds - value2.durationSeconds) > epsilon))
 303   {
 304     fprintf(stderr, "%s, checking durations %f == %f, epsilon %f\n", location, value1.durationSeconds, value2.durationSeconds, epsilon);
 305     tet_result(TET_FAIL);
 306   }
 307   else if ((fabs(value1.delaySeconds - value2.delaySeconds) > epsilon))
 308   {
 309     fprintf(stderr, "%s, checking delays %f == %f, epsilon %f\n", location, value1.delaySeconds, value2.delaySeconds, epsilon);
 310     tet_result(TET_FAIL);
 311   }
 312   else
 313   {
 314     tet_result(TET_PASS);
 315   }
 316 }
 317
 318 /**
 319  * Test whether two base handles are equal.
 320  * @param[in] baseHandle1 The first value
 321  * @param[in] baseHandle2 The second value
 322  * @param[in] location The TEST_LOCATION macro should be used here
 323  */
 324 void DALI_TEST_EQUALS( const BaseHandle& baseHandle1, const BaseHandle& baseHandle2, const char* location );
 325
 326 /**
 327  * Test whether a size_t value and an unsigned int are equal.
 328  * @param[in] value1 The first value
 329  * @param[in] value2 The second value
 330  * @param[in] location The TEST_LOCATION macro should be used here
 331  */
 332 void DALI_TEST_EQUALS( const size_t value1, const unsigned int value2, const char* location );
 333
 334 /**
 335  * Test whether an unsigned int and a size_t value and are equal.
 336  * @param[in] value1 The first value
 337  * @param[in] value2 The second value
 338  * @param[in] location The TEST_LOCATION macro should be used here
 339  */
 340 void DALI_TEST_EQUALS( const unsigned int value1, const size_t value2, const char* location );
 341
 342 /**
 343  * Test whether two Matrix3 objects are equal.
 344  * @param[in] matrix1 The first object
 345  * @param[in] matrix2 The second object
 346  * @param[in] location The TEST_LOCATION macro should be used here
 347  */
 348 void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, const char* location);
 349
 350 /** Test whether two Matrix3 objects are equal (fuzzy compare).
 351  * @param[in] matrix1 The first object
 352  * @param[in] matrix2 The second object
 353  * @param[in] epsilon The epsilon to use for comparison
 354  * @param[in] location The TEST_LOCATION macro should be used here
 355  */
 356 void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, float epsilon, const char* location);
 357
 358 /**
 359  * Test whether two Matrix objects are equal.
 360  * @param[in] matrix1 The first object
 361  * @param[in] matrix2 The second object
 362  * @param[in] location The TEST_LOCATION macro should be used here
 363  */
 364 void DALI_TEST_EQUALS( const Matrix& matrix1, const Matrix& matrix2, const char* location);
 365
 366 /**
 367  * Test whether two Matrix objects are equal (fuzzy-compare).
 368  * @param[in] matrix1 The first object
 369  * @param[in] matrix2 The second object
 370  * @param[in] location The TEST_LOCATION macro should be used here
 371  */
 372 void DALI_TEST_EQUALS( const Matrix& matrix1, const Matrix& matrix2, float epsilon, const char* location);
 373
 374 /**
 375  * Test whether two strings are equal.
 376  * @param[in] str1 The first string
 377  * @param[in] str2 The second string
 378  * @param[in] location The TEST_LOCATION macro should be used here
 379  */
 380 template<>
 381 inline void DALI_TEST_EQUALS<const char*>( const char* str1, const char* str2, const char* location)
 382 {
 383   if (strcmp(str1, str2))
 384   {
 385     fprintf(stderr, "%s, checking '%s' == '%s'\n", location, str1, str2);
 386     tet_result(TET_FAIL);
 387   }
 388   else
 389   {
 390     tet_result(TET_PASS);
 391   }
 392 }
 393
 394 /**
 395  * Test whether two strings are equal.
 396  * @param[in] str1 The first string
 397  * @param[in] str2 The second string
 398  * @param[in] location The TEST_LOCATION macro should be used here
 399  */
 400 template<>
 401 inline void DALI_TEST_EQUALS<const std::string&>( const std::string &str1, const std::string &str2, const char* location)
 402 {
 403   DALI_TEST_EQUALS(str1.c_str(), str2.c_str(), location);
 404 }
 405
 406 /**
 407  * Test whether two strings are equal.
 408  * @param[in] str1 The first string
 409  * @param[in] str2 The second string
 410  * @param[in] location The TEST_LOCATION macro should be used here
 411  */
 412 void DALI_TEST_EQUALS( Property::Value& str1, const char* str2, const char* location);
 413
 414 /**
 415  * Test whether two strings are equal.
 416  * @param[in] str1 The first string
 417  * @param[in] str2 The second string
 418  * @param[in] location The TEST_LOCATION macro should be used here
 419  */
 420 void DALI_TEST_EQUALS( const std::string &str1, const char* str2, const char* location);
 421
 422 /**
 423  * Test whether two strings are equal.
 424  * @param[in] str1 The first string
 425  * @param[in] str2 The second string
 426  * @param[in] location The TEST_LOCATION macro should be used here
 427  */
 428 void DALI_TEST_EQUALS( const char* str1, const std::string &str2, const char* location);
 429
 430 /**
 431  * Test whether one unsigned integer value is greater than another.
 432  * Test succeeds if value1 > value2
 433  * @param[in] value1 The first value
 434  * @param[in] value2 The second value
 435  * @param[in] location The TEST_LOCATION macro should be used here
 436  */
 437 template< typename T >
 438 void DALI_TEST_GREATER( T value1, T value2, const char* location)
 439 {
 440   if (!(value1 > value2))
 441   {
 442     std::cerr << location << ", checking " << value1 <<" > " << value2 << "\n";
 443     tet_result(TET_FAIL);
 444   }
 445   else
 446   {
 447     tet_result(TET_PASS);
 448   }
 449 }
 450
 451 /**
 452  * Test whether the assertion condition that failed and thus triggered the
 453  * exception \b e contained a given substring.
 454  * @param[in] e The exception that we expect was fired by a runtime assertion failure.
 455  * @param[in] conditionSubString The text that we expect to be present in an
 456  *                               assertion which triggered the exception.
 457  * @param[in] location The TEST_LOCATION macro should be used here.
 458  */
 459 void DALI_TEST_ASSERT( DaliException& e, std::string conditionSubString, const char* location );
 460
 461 /**
 462  * Print the assert
 463  * @param[in] e The exception that we expect was fired by a runtime assertion failure.
 464  */
 465 inline void DALI_TEST_PRINT_ASSERT( DaliException& e )
 466 {
 467   tet_printf("Assertion %s failed at %s\n", e.condition, e.location );
 468 }
 469
 470 // Functor to test whether an Applied signal is emitted
 471 struct ConstraintAppliedCheck
 472 {
 473   ConstraintAppliedCheck( bool& signalReceived );
 474   void operator()( Constraint& constraint );
 475   void Reset();
 476   void CheckSignalReceived();
 477   void CheckSignalNotReceived();
 478   bool& mSignalReceived; // owned by individual tests
 479 };
 480
 481 /**
 482  * A Helper to test default functions
 483  */
 484 template <typename T>
 485 struct DefaultFunctionCoverage
 486 {
 487   DefaultFunctionCoverage()
 488   {
 489     T a;
 490     T *b = new T(a);
 491     DALI_TEST_CHECK(b);
 492     a = *b;
 493     delete b;
 494   }
 495 };
 496
 497
 498 // Helper to Create buffer image
 499 BufferImage CreateBufferImage();
 500 BufferImage CreateBufferImage(int width, int height, const Vector4& color);
 501
 502 // Test namespace to prevent pollution of Dali namespace, add Test helper functions here
 503 namespace Test
 504 {
 505 /**
 506  *  @brief
 507  *
 508  *  Helper to check object destruction occurred
 509  *  1) In main part of code create an ObjectDestructionTracker
 510  *  2) Within sub section of main create object Actor test and call Start with Actor to test for destruction
 511  *  3) Perform code which is expected to destroy Actor
 512  *  4) Back in main part of code use IsDestroyed() to test if Actor was destroyed
 513  */
 514 class ObjectDestructionTracker : public ConnectionTracker
 515 {
 516 public:
 517
 518   /**
 519    * @brief Call in main part of code
 520    */
 521   ObjectDestructionTracker();
 522
 523   /**
 524    * @brief Call in sub bock of code where the Actor being checked is still alive.
 525    *
 526    * @param[in] actor Actor to be checked for destruction
 527    */
 528   void Start( Actor actor );
 529
 530   /**
 531    * @brief Call to check if Actor alive or destroyed.
 532    *
 533    * @return bool true if Actor was destroyed
 534    */
 535   bool IsDestroyed();
 536
 537 private:
 538   bool mRefObjectDestroyed;
 539 };
 540
 541 } // namespace Test
 542
 543 #endif // __DALI_TEST_SUITE_UTILS_H__