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) 2015 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 /**
 276  * Test whether two TimePeriods are within a certain distance of each other.
 277  * @param[in] value1 The first value
 278  * @param[in] value2 The second value
 279  * @param[in] epsilon The values must be within this distance of each other
 280  * @param[in] location The TEST_LOCATION macro should be used here
 281  */
 282 template<>
 283 inline void DALI_TEST_EQUALS<TimePeriod>( TimePeriod value1, TimePeriod value2, float epsilon, const char* location)
 284 {
 285   if ((fabs(value1.durationSeconds - value2.durationSeconds) > epsilon))
 286   {
 287     fprintf(stderr, "%s, checking durations %f == %f, epsilon %f\n", location, value1.durationSeconds, value2.durationSeconds, epsilon);
 288     tet_result(TET_FAIL);
 289   }
 290   else if ((fabs(value1.delaySeconds - value2.delaySeconds) > epsilon))
 291   {
 292     fprintf(stderr, "%s, checking delays %f == %f, epsilon %f\n", location, value1.delaySeconds, value2.delaySeconds, epsilon);
 293     tet_result(TET_FAIL);
 294   }
 295   else
 296   {
 297     tet_result(TET_PASS);
 298   }
 299 }
 300
 301 /**
 302  * Test whether two base handles are equal.
 303  * @param[in] baseHandle1 The first value
 304  * @param[in] baseHandle2 The second value
 305  * @param[in] location The TEST_LOCATION macro should be used here
 306  */
 307 void DALI_TEST_EQUALS( const BaseHandle& baseHandle1, const BaseHandle& baseHandle2, const char* location );
 308
 309 /**
 310  * Test whether a size_t value and an unsigned int are equal.
 311  * @param[in] value1 The first value
 312  * @param[in] value2 The second value
 313  * @param[in] location The TEST_LOCATION macro should be used here
 314  */
 315 void DALI_TEST_EQUALS( const size_t value1, const unsigned int value2, const char* location );
 316
 317 /**
 318  * Test whether an unsigned int and a size_t value and are equal.
 319  * @param[in] value1 The first value
 320  * @param[in] value2 The second value
 321  * @param[in] location The TEST_LOCATION macro should be used here
 322  */
 323 void DALI_TEST_EQUALS( const unsigned int value1, const size_t value2, const char* location );
 324
 325 /**
 326  * Test whether two Matrix3 objects are equal.
 327  * @param[in] matrix1 The first object
 328  * @param[in] matrix2 The second object
 329  * @param[in] location The TEST_LOCATION macro should be used here
 330  */
 331 void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, const char* location);
 332
 333 /** Test whether two Matrix3 objects are equal (fuzzy compare).
 334  * @param[in] matrix1 The first object
 335  * @param[in] matrix2 The second object
 336  * @param[in] epsilon The epsilon to use for comparison
 337  * @param[in] location The TEST_LOCATION macro should be used here
 338  */
 339 void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, float epsilon, const char* location);
 340
 341 /**
 342  * Test whether two Matrix objects are equal.
 343  * @param[in] matrix1 The first object
 344  * @param[in] matrix2 The second object
 345  * @param[in] location The TEST_LOCATION macro should be used here
 346  */
 347 void DALI_TEST_EQUALS( const Matrix& matrix1, const Matrix& matrix2, const char* location);
 348
 349 /**
 350  * Test whether two Matrix objects are equal (fuzzy-compare).
 351  * @param[in] matrix1 The first object
 352  * @param[in] matrix2 The second object
 353  * @param[in] location The TEST_LOCATION macro should be used here
 354  */
 355 void DALI_TEST_EQUALS( const Matrix& matrix1, const Matrix& matrix2, float epsilon, const char* location);
 356
 357 /**
 358  * Test whether two strings are equal.
 359  * @param[in] str1 The first string
 360  * @param[in] str2 The second string
 361  * @param[in] location The TEST_LOCATION macro should be used here
 362  */
 363 template<>
 364 inline void DALI_TEST_EQUALS<const char*>( const char* str1, const char* str2, const char* location)
 365 {
 366   if (strcmp(str1, str2))
 367   {
 368     fprintf(stderr, "%s, checking '%s' == '%s'\n", location, str1, str2);
 369     tet_result(TET_FAIL);
 370   }
 371   else
 372   {
 373     tet_result(TET_PASS);
 374   }
 375 }
 376
 377 /**
 378  * Test whether two strings are equal.
 379  * @param[in] str1 The first string
 380  * @param[in] str2 The second string
 381  * @param[in] location The TEST_LOCATION macro should be used here
 382  */
 383 template<>
 384 inline void DALI_TEST_EQUALS<const std::string&>( const std::string &str1, const std::string &str2, const char* location)
 385 {
 386   DALI_TEST_EQUALS(str1.c_str(), str2.c_str(), location);
 387 }
 388
 389 /**
 390  * Test whether two strings are equal.
 391  * @param[in] str1 The first string
 392  * @param[in] str2 The second string
 393  * @param[in] location The TEST_LOCATION macro should be used here
 394  */
 395 void DALI_TEST_EQUALS( Property::Value& str1, const char* str2, const char* location);
 396
 397 /**
 398  * Test whether two strings are equal.
 399  * @param[in] str1 The first string
 400  * @param[in] str2 The second string
 401  * @param[in] location The TEST_LOCATION macro should be used here
 402  */
 403 void DALI_TEST_EQUALS( const std::string &str1, const char* str2, const char* location);
 404
 405 /**
 406  * Test whether two strings are equal.
 407  * @param[in] str1 The first string
 408  * @param[in] str2 The second string
 409  * @param[in] location The TEST_LOCATION macro should be used here
 410  */
 411 void DALI_TEST_EQUALS( const char* str1, const std::string &str2, const char* location);
 412
 413 /**
 414  * Test whether one unsigned integer value is greater than another.
 415  * Test succeeds if value1 > value2
 416  * @param[in] value1 The first value
 417  * @param[in] value2 The second value
 418  * @param[in] location The TEST_LOCATION macro should be used here
 419  */
 420 template< typename T >
 421 void DALI_TEST_GREATER( T value1, T value2, const char* location)
 422 {
 423   if (!(value1 > value2))
 424   {
 425     std::cerr << location << ", checking " << value1 <<" > " << value2 << "\n";
 426     tet_result(TET_FAIL);
 427   }
 428   else
 429   {
 430     tet_result(TET_PASS);
 431   }
 432 }
 433
 434 /**
 435  * Test whether the assertion condition that failed and thus triggered the
 436  * exception \b e contained a given substring.
 437  * @param[in] e The exception that we expect was fired by a runtime assertion failure.
 438  * @param[in] conditionSubString The text that we expect to be present in an
 439  *                               assertion which triggered the exception.
 440  * @param[in] location The TEST_LOCATION macro should be used here.
 441  */
 442 void DALI_TEST_ASSERT( DaliException& e, std::string conditionSubString, const char* location );
 443
 444 /**
 445  * Print the assert
 446  * @param[in] e The exception that we expect was fired by a runtime assertion failure.
 447  */
 448 inline void DALI_TEST_PRINT_ASSERT( DaliException& e )
 449 {
 450   tet_printf("Assertion %s failed at %s\n", e.condition, e.location );
 451 }
 452
 453 // Functor to test whether an Applied signal is emitted
 454 struct ConstraintAppliedCheck
 455 {
 456   ConstraintAppliedCheck( bool& signalReceived );
 457   void operator()( Constraint& constraint );
 458   void Reset();
 459   void CheckSignalReceived();
 460   void CheckSignalNotReceived();
 461   bool& mSignalReceived; // owned by individual tests
 462 };
 463
 464 /**
 465  * A Helper to test default functions
 466  */
 467 template <typename T>
 468 struct DefaultFunctionCoverage
 469 {
 470   DefaultFunctionCoverage()
 471   {
 472     T a;
 473     T *b = new T(a);
 474     DALI_TEST_CHECK(b);
 475     a = *b;
 476     delete b;
 477   }
 478 };
 479
 480
 481 // Helper to Create buffer image
 482 BufferImage CreateBufferImage();
 483 BufferImage CreateBufferImage(int width, int height, const Vector4& color);
 484
 485 #endif // __DALI_TEST_SUITE_UTILS_H__