X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali-toolkit%2Fdali-toolkit-test-utils%2Fdali-test-suite-utils.h;h=a3149f4b459c30022a361459ee020d56035be607;hp=736a7244c6b7b4ecafda86060f0726809f1afe72;hb=2cfc2d43f2365794591eddc96f6c5ec029cab28d;hpb=297b1b9a9b6ed72fe98d5afb018ff4d1c951ce7d diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.h index 736a724..a3149f4 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.h +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.h @@ -2,7 +2,7 @@ #define __DALI_TEST_SUITE_UTILS_H__ /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2016 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,14 +18,18 @@ * */ +// EXTERNAL INCLUDES +#include +#include + // INTERNAL INCLUDES #include -#include void tet_infoline(const char*str); void tet_printf(const char *format, ...); #include "test-application.h" +#include "test-actor-utils.h" using namespace Dali; @@ -54,7 +58,7 @@ void tet_printf(const char *format, ...); /** * DALI_TEST_CHECK is a wrapper for tet_result. - * If the condition evaluates to false, then the function & line number is printed. + * If the condition evaluates to false, the test is stopped. * @param[in] The boolean expression to check */ #define DALI_TEST_CHECK(condition) \ @@ -66,6 +70,7 @@ else { \ fprintf(stderr, "%s Failed in %s at line %d\n", __PRETTY_FUNCTION__, __FILE__, __LINE__); \ tet_result(TET_FAIL); \ + throw("TET_FAIL"); \ } template @@ -139,17 +144,95 @@ inline bool CompareType(Quaternion q1, Quaternion q2, float epsilon) template <> inline bool CompareType(Radian q1, Radian q2, float epsilon) { - return CompareType(float(q1), float(q2), epsilon); + return CompareType(q1.radian, q2.radian, epsilon); } template <> inline bool CompareType(Degree q1, Degree q2, float epsilon) { - return CompareType(float(q1), float(q2), epsilon); + return CompareType(q1.degree, q2.degree, epsilon); +} + +template <> +inline bool CompareType(Property::Value q1, Property::Value q2, float epsilon) +{ + Property::Type type = q1.GetType(); + if( type != q2.GetType() ) + { + return false; + } + + switch(type) + { + case Property::BOOLEAN: + { + bool a, b; + q1.Get(a); + q2.Get(b); + return a == b; + break; + } + case Property::INTEGER: + { + int a, b; + q1.Get(a); + q2.Get(b); + return a == b; + break; + } + case Property::FLOAT: + { + float a, b; + q1.Get(a); + q2.Get(b); + return CompareType(a, b, epsilon); + break; + } + case Property::VECTOR2: + { + Vector2 a, b; + q1.Get(a); + q2.Get(b); + return CompareType(a, b, epsilon); + break; + } + case Property::VECTOR3: + { + Vector3 a, b; + q1.Get(a); + q2.Get(b); + return CompareType(a, b, epsilon); + break; + } + case Property::RECTANGLE: + case Property::VECTOR4: + { + Vector4 a, b; + q1.Get(a); + q2.Get(b); + return CompareType(a, b, epsilon); + break; + } + case Property::ROTATION: + { + Quaternion a, b; + q1.Get(a); + q2.Get(b); + return CompareType(a, b, epsilon); + break; + } + default: + return false; + } + + return false; } + bool operator==(TimePeriod a, TimePeriod b); -std::ostream& operator<< (std::ostream& o, const TimePeriod value); +std::ostream& operator<<( std::ostream& ostream, TimePeriod value ); +std::ostream& operator<<( std::ostream& ostream, Radian angle ); +std::ostream& operator<<( std::ostream& ostream, Degree angle ); /** * Test whether two values are equal. @@ -157,8 +240,8 @@ std::ostream& operator<< (std::ostream& o, const TimePeriod value); * @param[in] value2 The second value * @param[in] location The TEST_LOCATION macro should be used here */ -template -inline void DALI_TEST_EQUALS(TypeA value1, TypeB value2, const char* location) +template +inline void DALI_TEST_EQUALS(Type value1, Type value2, const char* location) { if (!(value1 == value2)) { @@ -189,6 +272,23 @@ inline void DALI_TEST_EQUALS(Type value1, Type value2, float epsilon, const char } } +template +inline void DALI_TEST_NOT_EQUALS(Type value1, Type value2, float epsilon, const char* location) +{ + if( CompareType(value1, value2, epsilon) ) + { + std::ostringstream o; + o << value1 << " != " << value2 << std::endl; + fprintf(stderr, "%s, checking %s", location, o.str().c_str()); + tet_result(TET_FAIL); + } + else + { + tet_result(TET_PASS); + } +} + + /** * Test whether two TimePeriods are within a certain distance of each other. * @param[in] value1 The first value @@ -216,6 +316,30 @@ inline void DALI_TEST_EQUALS( TimePeriod value1, TimePeriod value2, } /** + * Test whether two base handles are equal. + * @param[in] baseHandle1 The first value + * @param[in] baseHandle2 The second value + * @param[in] location The TEST_LOCATION macro should be used here + */ +void DALI_TEST_EQUALS( const BaseHandle& baseHandle1, const BaseHandle& baseHandle2, const char* location ); + +/** + * Test whether a size_t value and an unsigned int are equal. + * @param[in] value1 The first value + * @param[in] value2 The second value + * @param[in] location The TEST_LOCATION macro should be used here + */ +void DALI_TEST_EQUALS( const size_t value1, const unsigned int value2, const char* location ); + +/** + * Test whether an unsigned int and a size_t value and are equal. + * @param[in] value1 The first value + * @param[in] value2 The second value + * @param[in] location The TEST_LOCATION macro should be used here + */ +void DALI_TEST_EQUALS( const unsigned int value1, const size_t value2, const char* location ); + +/** * Test whether two Matrix3 objects are equal. * @param[in] matrix1 The first object * @param[in] matrix2 The second object @@ -285,7 +409,7 @@ inline void DALI_TEST_EQUALS( const std::string &str1, const * @param[in] str2 The second string * @param[in] location The TEST_LOCATION macro should be used here */ -void DALI_TEST_EQUALS( const std::string &str1, const char* str2, const char* location); +void DALI_TEST_EQUALS( Property::Value& str1, const char* str2, const char* location); /** * Test whether two strings are equal. @@ -293,25 +417,36 @@ void DALI_TEST_EQUALS( const std::string &str1, const char* str2, const char* lo * @param[in] str2 The second string * @param[in] location The TEST_LOCATION macro should be used here */ -void DALI_TEST_EQUALS( const char* str1, const std::string &str2, const char* location); +void DALI_TEST_EQUALS( const std::string &str1, const char* str2, const char* location); /** - * Test whether one unsigned integer value is greater than another. - * Test succeeds if value1 > value2 - * @param[in] value1 The first value - * @param[in] value2 The second value + * Test whether two strings are equal. + * @param[in] str1 The first string + * @param[in] str2 The second string * @param[in] location The TEST_LOCATION macro should be used here */ -void DALI_TEST_GREATER(unsigned int value1, unsigned int value2, const char* location); +void DALI_TEST_EQUALS( const char* str1, const std::string &str2, const char* location); /** - * Test whether one float value is greater than another. + * Test whether one unsigned integer value is greater than another. * Test succeeds if value1 > value2 * @param[in] value1 The first value * @param[in] value2 The second value * @param[in] location The TEST_LOCATION macro should be used here */ -void DALI_TEST_GREATER( float value1, float value2, const char* location); +template< typename T > +void DALI_TEST_GREATER( T value1, T value2, const char* location) +{ + if (!(value1 > value2)) + { + std::cerr << location << ", checking " << value1 <<" > " << value2 << "\n"; + tet_result(TET_FAIL); + } + else + { + tet_result(TET_PASS); + } +} /** * Test whether the assertion condition that failed and thus triggered the @@ -336,7 +471,7 @@ inline void DALI_TEST_PRINT_ASSERT( DaliException& e ) struct ConstraintAppliedCheck { ConstraintAppliedCheck( bool& signalReceived ); - void operator()( ActiveConstraint& constraint ); + void operator()( Constraint& constraint ); void Reset(); void CheckSignalReceived(); void CheckSignalNotReceived(); @@ -360,9 +495,49 @@ struct DefaultFunctionCoverage }; -// Helper to Create bitmap image +// Helper to Create buffer image BufferImage CreateBufferImage(); BufferImage CreateBufferImage(int width, int height, const Vector4& color); +// Test namespace to prevent pollution of Dali namespace, add Test helper functions here +namespace Test +{ +/** + * @brief + * + * Helper to check object destruction occurred + * 1) In main part of code create an ObjectDestructionTracker + * 2) Within sub section of main create object Actor test and call Start with Actor to test for destruction + * 3) Perform code which is expected to destroy Actor + * 4) Back in main part of code use IsDestroyed() to test if Actor was destroyed + */ +class ObjectDestructionTracker : public ConnectionTracker +{ +public: + + /** + * @brief Call in main part of code + */ + ObjectDestructionTracker(); + + /** + * @brief Call in sub bock of code where the Actor being checked is still alive. + * + * @param[in] actor Actor to be checked for destruction + */ + void Start( Actor actor ); + + /** + * @brief Call to check if Actor alive or destroyed. + * + * @return bool true if Actor was destroyed + */ + bool IsDestroyed(); + +private: + bool mRefObjectDestroyed; +}; + +} // namespace Test #endif // __DALI_TEST_SUITE_UTILS_H__