1 #ifndef __DALI_TEST_SUITE_UTILS_H__
2 #define __DALI_TEST_SUITE_UTILS_H__
5 * Copyright (c) 2015 Samsung Electronics Co., Ltd.
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
26 #include <dali/public-api/dali-core.h>
28 void tet_infoline(const char*str);
29 void tet_printf(const char *format, ...);
31 #include "test-application.h"
32 #include "test-actor-utils.h"
36 #define STRINGIZE_I(text) #text
37 #define STRINGIZE(text) STRINGIZE_I(text)
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__) ) ) )
49 extern int test_return_value;
51 void tet_result(int value);
54 return ((test_return_value>0)?1:0)
56 void tet_infoline(const char* str);
57 void tet_printf(const char *format, ...);
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
64 #define DALI_TEST_CHECK(condition) \
67 tet_result(TET_PASS); \
71 fprintf(stderr, "%s Failed in %s at line %d\n", __PRETTY_FUNCTION__, __FILE__, __LINE__); \
72 tet_result(TET_FAIL); \
76 template <typename Type>
77 inline bool CompareType(Type value1, Type value2, float epsilon);
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
87 inline bool CompareType<float>(float value1, float value2, float epsilon)
89 return fabsf(value1 - value2) < epsilon;
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
100 inline bool CompareType<Vector2>(Vector2 vector1, Vector2 vector2, float epsilon)
102 return fabsf(vector1.x - vector2.x)<epsilon && fabsf(vector1.y - vector2.y)<epsilon;
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
113 inline bool CompareType<Vector3>(Vector3 vector1, Vector3 vector2, float epsilon)
115 return fabsf(vector1.x - vector2.x)<epsilon &&
116 fabsf(vector1.y - vector2.y)<epsilon &&
117 fabsf(vector1.z - vector2.z)<epsilon;
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
129 inline bool CompareType<Vector4>(Vector4 vector1, Vector4 vector2, float epsilon)
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;
138 inline bool CompareType<Quaternion>(Quaternion q1, Quaternion q2, float epsilon)
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);
145 inline bool CompareType<Radian>(Radian q1, Radian q2, float epsilon)
147 return CompareType<float>(q1.radian, q2.radian, epsilon);
151 inline bool CompareType<Degree>(Degree q1, Degree q2, float epsilon)
153 return CompareType<float>(q1.degree, q2.degree, epsilon);
157 inline bool CompareType<Property::Value>(Property::Value q1, Property::Value q2, float epsilon)
159 Property::Type type = q1.GetType();
160 if( type != q2.GetType() )
168 case Property::BOOLEAN:
176 case Property::INTEGER:
184 case Property::FLOAT:
189 result = CompareType<float>(a, b, epsilon);
192 case Property::VECTOR2:
197 result = CompareType<Vector2>(a, b, epsilon);
200 case Property::VECTOR3:
205 result = CompareType<Vector3>(a, b, epsilon);
208 case Property::RECTANGLE:
209 case Property::VECTOR4:
214 result = CompareType<Vector4>(a, b, epsilon);
217 case Property::ROTATION:
222 result = CompareType<Quaternion>(a, b, epsilon);
225 case Property::MATRIX:
226 case Property::MATRIX3:
227 case Property::STRING:
228 case Property::ARRAY:
231 //TODO: Implement this?
232 DALI_ASSERT_ALWAYS( 0 && "Not implemented");
247 bool operator==(TimePeriod a, TimePeriod b);
248 std::ostream& operator<<( std::ostream& ostream, TimePeriod value );
249 std::ostream& operator<<( std::ostream& ostream, Radian angle );
250 std::ostream& operator<<( std::ostream& ostream, Degree angle );
253 * Test whether two values are equal.
254 * @param[in] value1 The first value
255 * @param[in] value2 The second value
256 * @param[in] location The TEST_LOCATION macro should be used here
258 template<typename Type>
259 inline void DALI_TEST_EQUALS(Type value1, Type value2, const char* location)
261 if (!(value1 == value2))
263 std::ostringstream o;
264 o << value1 << " == " << value2 << std::endl;
265 fprintf(stderr, "%s, checking %s", location, o.str().c_str());
266 tet_result(TET_FAIL);
270 tet_result(TET_PASS);
274 template<typename Type>
275 inline void DALI_TEST_EQUALS(Type value1, Type value2, float epsilon, const char* location)
277 if( !CompareType<Type>(value1, value2, epsilon) )
279 std::ostringstream o;
280 o << value1 << " == " << value2 << std::endl;
281 fprintf(stderr, "%s, checking %s", location, o.str().c_str());
282 tet_result(TET_FAIL);
286 tet_result(TET_PASS);
290 template<typename Type>
291 inline void DALI_TEST_NOT_EQUALS(Type value1, Type value2, float epsilon, const char* location)
293 if( CompareType<Type>(value1, value2, epsilon) )
295 std::ostringstream o;
296 o << value1 << " != " << value2 << std::endl;
297 fprintf(stderr, "%s, checking %s", location, o.str().c_str());
298 tet_result(TET_FAIL);
302 tet_result(TET_PASS);
308 * Test whether two TimePeriods are within a certain distance of each other.
309 * @param[in] value1 The first value
310 * @param[in] value2 The second value
311 * @param[in] epsilon The values must be within this distance of each other
312 * @param[in] location The TEST_LOCATION macro should be used here
315 inline void DALI_TEST_EQUALS<TimePeriod>( TimePeriod value1, TimePeriod value2, float epsilon, const char* location)
317 if ((fabs(value1.durationSeconds - value2.durationSeconds) > epsilon))
319 fprintf(stderr, "%s, checking durations %f == %f, epsilon %f\n", location, value1.durationSeconds, value2.durationSeconds, epsilon);
320 tet_result(TET_FAIL);
322 else if ((fabs(value1.delaySeconds - value2.delaySeconds) > epsilon))
324 fprintf(stderr, "%s, checking delays %f == %f, epsilon %f\n", location, value1.delaySeconds, value2.delaySeconds, epsilon);
325 tet_result(TET_FAIL);
329 tet_result(TET_PASS);
334 * Test whether two base handles are equal.
335 * @param[in] baseHandle1 The first value
336 * @param[in] baseHandle2 The second value
337 * @param[in] location The TEST_LOCATION macro should be used here
339 void DALI_TEST_EQUALS( const BaseHandle& baseHandle1, const BaseHandle& baseHandle2, const char* location );
342 * Test whether a size_t value and an unsigned int are equal.
343 * @param[in] value1 The first value
344 * @param[in] value2 The second value
345 * @param[in] location The TEST_LOCATION macro should be used here
347 void DALI_TEST_EQUALS( const size_t value1, const unsigned int value2, const char* location );
350 * Test whether an unsigned int and a size_t value and are equal.
351 * @param[in] value1 The first value
352 * @param[in] value2 The second value
353 * @param[in] location The TEST_LOCATION macro should be used here
355 void DALI_TEST_EQUALS( const unsigned int value1, const size_t value2, const char* location );
358 * Test whether two Matrix3 objects are equal.
359 * @param[in] matrix1 The first object
360 * @param[in] matrix2 The second object
361 * @param[in] location The TEST_LOCATION macro should be used here
363 void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, const char* location);
365 /** Test whether two Matrix3 objects are equal (fuzzy compare).
366 * @param[in] matrix1 The first object
367 * @param[in] matrix2 The second object
368 * @param[in] epsilon The epsilon to use for comparison
369 * @param[in] location The TEST_LOCATION macro should be used here
371 void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, float epsilon, const char* location);
374 * Test whether two Matrix objects are equal.
375 * @param[in] matrix1 The first object
376 * @param[in] matrix2 The second object
377 * @param[in] location The TEST_LOCATION macro should be used here
379 void DALI_TEST_EQUALS( const Matrix& matrix1, const Matrix& matrix2, const char* location);
382 * Test whether two Matrix objects are equal (fuzzy-compare).
383 * @param[in] matrix1 The first object
384 * @param[in] matrix2 The second object
385 * @param[in] location The TEST_LOCATION macro should be used here
387 void DALI_TEST_EQUALS( const Matrix& matrix1, const Matrix& matrix2, float epsilon, const char* location);
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
396 inline void DALI_TEST_EQUALS<const char*>( const char* str1, const char* str2, const char* location)
398 if (strcmp(str1, str2))
400 fprintf(stderr, "%s, checking '%s' == '%s'\n", location, str1, str2);
401 tet_result(TET_FAIL);
405 tet_result(TET_PASS);
410 * Test whether two strings are equal.
411 * @param[in] str1 The first string
412 * @param[in] str2 The second string
413 * @param[in] location The TEST_LOCATION macro should be used here
416 inline void DALI_TEST_EQUALS<const std::string&>( const std::string &str1, const std::string &str2, const char* location)
418 DALI_TEST_EQUALS(str1.c_str(), str2.c_str(), location);
422 * Test whether two strings are equal.
423 * @param[in] str1 The first string
424 * @param[in] str2 The second string
425 * @param[in] location The TEST_LOCATION macro should be used here
427 void DALI_TEST_EQUALS( Property::Value& str1, const char* str2, const char* location);
430 * Test whether two strings are equal.
431 * @param[in] str1 The first string
432 * @param[in] str2 The second string
433 * @param[in] location The TEST_LOCATION macro should be used here
435 void DALI_TEST_EQUALS( const std::string &str1, const char* str2, const char* location);
438 * Test whether two strings are equal.
439 * @param[in] str1 The first string
440 * @param[in] str2 The second string
441 * @param[in] location The TEST_LOCATION macro should be used here
443 void DALI_TEST_EQUALS( const char* str1, const std::string &str2, const char* location);
446 * Test whether one unsigned integer value is greater than another.
447 * Test succeeds if value1 > value2
448 * @param[in] value1 The first value
449 * @param[in] value2 The second value
450 * @param[in] location The TEST_LOCATION macro should be used here
452 template< typename T >
453 void DALI_TEST_GREATER( T value1, T value2, const char* location)
455 if (!(value1 > value2))
457 std::cerr << location << ", checking " << value1 <<" > " << value2 << "\n";
458 tet_result(TET_FAIL);
462 tet_result(TET_PASS);
467 * Test whether the assertion condition that failed and thus triggered the
468 * exception \b e contained a given substring.
469 * @param[in] e The exception that we expect was fired by a runtime assertion failure.
470 * @param[in] conditionSubString The text that we expect to be present in an
471 * assertion which triggered the exception.
472 * @param[in] location The TEST_LOCATION macro should be used here.
474 void DALI_TEST_ASSERT( DaliException& e, std::string conditionSubString, const char* location );
478 * @param[in] e The exception that we expect was fired by a runtime assertion failure.
480 inline void DALI_TEST_PRINT_ASSERT( DaliException& e )
482 tet_printf("Assertion %s failed at %s\n", e.condition, e.location );
485 // Functor to test whether an Applied signal is emitted
486 struct ConstraintAppliedCheck
488 ConstraintAppliedCheck( bool& signalReceived );
489 void operator()( Constraint& constraint );
491 void CheckSignalReceived();
492 void CheckSignalNotReceived();
493 bool& mSignalReceived; // owned by individual tests
497 * A Helper to test default functions
499 template <typename T>
500 struct DefaultFunctionCoverage
502 DefaultFunctionCoverage()
513 // Helper to Create buffer image
514 BufferImage CreateBufferImage();
515 BufferImage CreateBufferImage(int width, int height, const Vector4& color);
517 // Prepare a resource image to be loaded. Should be called before creating the ResourceImage
518 void PrepareResourceImage( TestApplication& application, unsigned int imageWidth, unsigned int imageHeight, Pixel::Format pixelFormat );
520 // Test namespace to prevent pollution of Dali namespace, add Test helper functions here
526 * Helper to check object destruction occurred
527 * 1) In main part of code create an ObjectDestructionTracker
528 * 2) Within sub section of main create object Actor test and call Start with Actor to test for destruction
529 * 3) Perform code which is expected to destroy Actor
530 * 4) Back in main part of code use IsDestroyed() to test if Actor was destroyed
532 class ObjectDestructionTracker : public ConnectionTracker
537 * @brief Call in main part of code
539 ObjectDestructionTracker();
542 * @brief Call in sub bock of code where the Actor being checked is still alive.
544 * @param[in] actor Actor to be checked for destruction
546 void Start( Actor actor );
549 * @brief Call to check if Actor alive or destroyed.
551 * @return bool true if Actor was destroyed
556 bool mRefObjectDestroyed;
561 #endif // __DALI_TEST_SUITE_UTILS_H__