1 #ifndef DALI_TEST_SUITE_UTILS_H
2 #define DALI_TEST_SUITE_UTILS_H
5 * Copyright (c) 2020 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.
29 #include <dali/public-api/dali-core.h>
30 #include <test-compare-types.h>
34 void tet_infoline(const char*str);
35 void tet_printf(const char *format, ...);
38 #include "test-application.h"
39 #include "test-actor-utils.h"
40 #include "test-gesture-generator.h"
44 #define STRINGIZE_I(text) #text
45 #define STRINGIZE(text) STRINGIZE_I(text)
48 * Inspired by https://stackoverflow.com/questions/1706346/file-macro-manipulation-handling-at-compile-time
49 * answer by Chetan Reddy
51 constexpr int32_t basenameIndex( const char * const path, const int32_t index = 0, const int32_t slashIndex = -1 )
54 ? ( path[ index ] == '/'
55 ? basenameIndex( path, index + 1, index )
56 : basenameIndex( path, index + 1, slashIndex ) )
60 #define __FILELINE__ ( { static const int32_t basenameIdx = basenameIndex( __FILE__ ); \
61 static_assert (basenameIdx >= 0, "compile-time basename" ); \
62 __FILE__ ":" STRINGIZE(__LINE__) + basenameIdx ; } )
64 #define TEST_LOCATION __FILELINE__
65 #define TEST_INNER_LOCATION(x) ( std::string(x) + " (" + STRINGIZE(__LINE__) + ")" ).c_str()
71 extern int32_t test_return_value;
73 void tet_result(int32_t value);
76 return ((test_return_value>0)?1:0)
78 void tet_infoline(const char* str);
79 void tet_printf(const char *format, ...);
82 * DALI_TEST_CHECK is a wrapper for tet_result.
83 * If the condition evaluates to false, the test is stopped.
84 * @param[in] The boolean expression to check
86 #define DALI_TEST_CHECK(condition) \
89 tet_result(TET_PASS); \
93 fprintf(stderr, "Test failed in %s, condition: %s\n", __FILELINE__, #condition ); \
94 tet_result(TET_FAIL); \
99 bool operator==(TimePeriod a, TimePeriod b);
100 std::ostream& operator<<( std::ostream& ostream, TimePeriod value );
101 std::ostream& operator<<( std::ostream& ostream, Radian angle );
102 std::ostream& operator<<( std::ostream& ostream, Degree angle );
105 * Test whether two values are equal.
106 * @param[in] value1 The first value
107 * @param[in] value2 The second value
108 * @param[in] location The TEST_LOCATION macro should be used here
110 template<typename Type>
111 inline void DALI_TEST_EQUALS(Type value1, Type value2, const char* location)
113 if( !CompareType<Type>(value1, value2, 0.01f) )
115 std::ostringstream o;
116 o << value1 << " == " << value2 << std::endl;
117 fprintf(stderr, "Test failed in %s, checking %s", location, o.str().c_str());
118 tet_result(TET_FAIL);
123 tet_result(TET_PASS);
128 * Test whether two values are equal.
129 * @param[in] value1 The first value
130 * @param[in] value2 The second value
132 #define DALI_TEST_EQUAL( v1, v2 ) DALI_TEST_EQUALS( v1, v2, __FILELINE__ )
134 template<typename Type>
135 inline void DALI_TEST_EQUALS(Type value1, Type value2, float epsilon, const char* location)
137 if( !CompareType<Type>(value1, value2, epsilon) )
139 std::ostringstream o;
140 o << value1 << " == " << value2 << std::endl;
141 fprintf(stderr, "Test failed in %s, checking %s", location, o.str().c_str());
142 tet_result(TET_FAIL);
147 tet_result(TET_PASS);
151 template<typename Type>
152 inline void DALI_TEST_NOT_EQUALS(Type value1, Type value2, float epsilon, const char* location)
154 if( CompareType<Type>(value1, value2, epsilon) )
156 std::ostringstream o;
157 o << value1 << " != " << value2 << std::endl;
158 fprintf(stderr, "Test failed in %s, checking %s", location, o.str().c_str());
159 tet_result(TET_FAIL);
164 tet_result(TET_PASS);
170 * Test whether two TimePeriods are within a certain distance of each other.
171 * @param[in] value1 The first value
172 * @param[in] value2 The second value
173 * @param[in] epsilon The values must be within this distance of each other
174 * @param[in] location The TEST_LOCATION macro should be used here
177 inline void DALI_TEST_EQUALS<TimePeriod>( TimePeriod value1, TimePeriod value2, float epsilon, const char* location)
179 if ((fabs(value1.durationSeconds - value2.durationSeconds) > epsilon))
181 fprintf(stderr, "Test failed in %s, checking durations %f == %f, epsilon %f\n", location, value1.durationSeconds, value2.durationSeconds, epsilon);
182 tet_result(TET_FAIL);
185 else if ((fabs(value1.delaySeconds - value2.delaySeconds) > epsilon))
187 fprintf(stderr, "Test failed in %s, checking delays %f == %f, epsilon %f\n", location, value1.delaySeconds, value2.delaySeconds, epsilon);
188 tet_result(TET_FAIL);
193 tet_result(TET_PASS);
198 * Test whether two base handles are equal.
199 * @param[in] baseHandle1 The first value
200 * @param[in] baseHandle2 The second value
201 * @param[in] location The TEST_LOCATION macro should be used here
203 void DALI_TEST_EQUALS( const BaseHandle& baseHandle1, const BaseHandle& baseHandle2, const char* location );
206 * Test whether a size_t value and an uint32_t are equal.
207 * @param[in] value1 The first value
208 * @param[in] value2 The second value
209 * @param[in] location The TEST_LOCATION macro should be used here
211 void DALI_TEST_EQUALS( const size_t value1, const uint32_t value2, const char* location );
214 * Test whether an uint32_t and a size_t value and are equal.
215 * @param[in] value1 The first value
216 * @param[in] value2 The second value
217 * @param[in] location The TEST_LOCATION macro should be used here
219 void DALI_TEST_EQUALS( const uint32_t value1, const size_t value2, const char* location );
222 * Test whether two Matrix3 objects are equal.
223 * @param[in] matrix1 The first object
224 * @param[in] matrix2 The second object
225 * @param[in] location The TEST_LOCATION macro should be used here
227 void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, const char* location);
229 /** Test whether two Matrix3 objects are equal (fuzzy compare).
230 * @param[in] matrix1 The first object
231 * @param[in] matrix2 The second object
232 * @param[in] epsilon The epsilon to use for comparison
233 * @param[in] location The TEST_LOCATION macro should be used here
235 void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, float epsilon, const char* location);
238 * Test whether two Matrix objects are equal.
239 * @param[in] matrix1 The first object
240 * @param[in] matrix2 The second object
241 * @param[in] location The TEST_LOCATION macro should be used here
243 void DALI_TEST_EQUALS( const Matrix& matrix1, const Matrix& matrix2, const char* location);
246 * Test whether two Matrix objects are equal (fuzzy-compare).
247 * @param[in] matrix1 The first object
248 * @param[in] matrix2 The second object
249 * @param[in] location The TEST_LOCATION macro should be used here
251 void DALI_TEST_EQUALS( const Matrix& matrix1, const Matrix& matrix2, float epsilon, const char* location);
254 * Test whether two strings are equal.
255 * @param[in] str1 The first string
256 * @param[in] str2 The second string
257 * @param[in] location The TEST_LOCATION macro should be used here
260 inline void DALI_TEST_EQUALS<const char*>( const char* str1, const char* str2, const char* location)
262 if (strcmp(str1, str2))
264 fprintf(stderr, "Test failed in %s, checking '%s' == '%s'\n", location, str1, str2);
265 tet_result(TET_FAIL);
270 tet_result(TET_PASS);
275 * Test whether two strings are equal.
276 * @param[in] str1 The first string
277 * @param[in] str2 The second string
278 * @param[in] location The TEST_LOCATION macro should be used here
281 inline void DALI_TEST_EQUALS<const std::string&>( const std::string &str1, const std::string &str2, const char* location)
283 DALI_TEST_EQUALS(str1.c_str(), str2.c_str(), location);
287 * Test whether two strings are equal.
288 * @param[in] str1 The first string
289 * @param[in] str2 The second string
290 * @param[in] location The TEST_LOCATION macro should be used here
292 void DALI_TEST_EQUALS( Property::Value& str1, const char* str2, const char* location);
295 * Test whether two strings are equal.
296 * @param[in] str1 The first string
297 * @param[in] str2 The second string
298 * @param[in] location The TEST_LOCATION macro should be used here
300 void DALI_TEST_EQUALS( const std::string &str1, const char* str2, const char* location);
303 * Test whether two strings are equal.
304 * @param[in] str1 The first string
305 * @param[in] str2 The second string
306 * @param[in] location The TEST_LOCATION macro should be used here
308 void DALI_TEST_EQUALS( const char* str1, const std::string &str2, const char* location);
311 * Test if a property value type is equal to a trivial type.
313 template<typename Type>
314 inline void DALI_TEST_VALUE_EQUALS( Property::Value&& value1, Type value2, float epsilon, const char* location)
316 Property::Value value2b(value2);
317 DALI_TEST_EQUALS(value1, value2b, epsilon, location);
322 * Test whether one unsigned integer value is greater than another.
323 * Test succeeds if value1 > value2
324 * @param[in] value1 The first value
325 * @param[in] value2 The second value
326 * @param[in] location The TEST_LOCATION macro should be used here
328 template< typename T >
329 void DALI_TEST_GREATER( T value1, T value2, const char* location)
331 if (!(value1 > value2))
333 std::cerr << "Test failed in " << location << ", checking " << value1 <<" > " << value2 << "\n";
334 tet_result(TET_FAIL);
339 tet_result(TET_PASS);
344 * Test whether the assertion condition that failed and thus triggered the
345 * exception \b e contained a given substring.
346 * @param[in] e The exception that we expect was fired by a runtime assertion failure.
347 * @param[in] conditionSubString The text that we expect to be present in an
348 * assertion which triggered the exception.
349 * @param[in] location The TEST_LOCATION macro should be used here.
351 void DALI_TEST_ASSERT( DaliException& e, std::string conditionSubString, const char* location );
355 * @param[in] e The exception that we expect was fired by a runtime assertion failure.
357 inline void DALI_TEST_PRINT_ASSERT( DaliException& e )
359 tet_printf("Assertion %s failed at %s\n", e.condition, e.location );
363 * Test that given piece of code triggers the right assertion
364 * Fails the test if the assert didn't occur.
365 * Turns off logging during the execution of the code to avoid excessive false positive log output from the assertions
366 * @param expressions code to execute
367 * @param assertstring the substring expected in the assert
369 #define DALI_TEST_ASSERTION( expressions, assertstring ) \
372 TestApplication::EnableLogging( false ); \
374 TestApplication::EnableLogging( true ); \
375 fprintf(stderr, "Test failed in %s, expected assert: '%s' didn't occur\n", __FILELINE__, assertstring ); \
376 tet_result(TET_FAIL); \
377 throw("TET_FAIL"); } \
378 catch( Dali::DaliException& e ) \
380 DALI_TEST_ASSERT( e, assertstring, TEST_LOCATION ); \
383 // Functor to test whether an Applied signal is emitted
384 struct ConstraintAppliedCheck
386 ConstraintAppliedCheck( bool& signalReceived );
387 void operator()( Constraint& constraint );
389 void CheckSignalReceived();
390 void CheckSignalNotReceived();
391 bool& mSignalReceived; // owned by individual tests
395 * A Helper to test default functions
397 template <typename T>
398 struct DefaultFunctionCoverage
400 DefaultFunctionCoverage()
410 // Test namespace to prevent pollution of Dali namespace, add Test helper functions here
416 * Helper to check object destruction occurred
417 * 1) In main part of code create an ObjectDestructionTracker
418 * 2) Within sub section of main create object Actor test and call Start with Actor to test for destruction
419 * 3) Perform code which is expected to destroy Actor
420 * 4) Back in main part of code use IsDestroyed() to test if Actor was destroyed
422 class ObjectDestructionTracker : public ConnectionTracker
427 * @brief Call in main part of code
428 * @param[in] objectRegistry The object Registry being used
430 ObjectDestructionTracker( ObjectRegistry objectRegistry );
433 * @brief Call in sub bock of code where the Actor being checked is still alive.
435 * @param[in] actor Actor to be checked for destruction
437 void Start( Actor actor );
440 * @brief Call to check if Actor alive or destroyed.
442 * @return bool true if Actor was destroyed
447 ObjectRegistry mObjectRegistry;
448 bool mRefObjectDestroyed;
453 #endif // DALI_TEST_SUITE_UTILS_H