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.cpp;h=299a0e1a0bf79dd08ba2486e887795c39cc10236;hp=8ceaed3fd4a2c6cc8b7e58ecd9fe4fa207e36ddf;hb=fede1dfcd3dee5076f26cb48d009f2375944e467;hpb=966b18f7fa3989309dbf22d38cbc7750785f8333 diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.cpp index 8ceaed3..299a0e1 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.cpp +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2020 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. @@ -15,91 +15,119 @@ * */ +// CLASS HEADER +#include "dali-test-suite-utils.h" + +// EXTERNAL INCLUDES +#include + // INTERNAL INCLUDES #include -#include - -#include "dali-test-suite-utils.h" using namespace Dali; -int test_return_value = TET_UNDEF; +int32_t test_return_value = TET_UNDEF; -void tet_result(int value) +void tet_result(int32_t value) { // First TET_PASS should set to zero // first TET_FAIL should prevent any further TET_PASS from setting back to zero // Any TET_FAIL should set to fail or leave as fail - if( test_return_value != 1 ) + if(test_return_value != 1) test_return_value = value; } #define END_TEST \ - return ((test_return_value>0)?1:0) + return ((test_return_value > 0) ? 1 : 0) +extern "C" +{ + void tet_infoline(const char* str) + { + fprintf(stderr, "%s\n", str); + } -void tet_infoline(const char* str) + void tet_printf(const char* format, ...) + { + va_list arg; + va_start(arg, format); + vfprintf(stderr, format, arg); + va_end(arg); + } +} + +bool operator==(TimePeriod a, TimePeriod b) { - fprintf(stderr, "%s\n", str); + return Equals(a.durationSeconds, b.durationSeconds) && Equals(a.delaySeconds, b.delaySeconds); } -void tet_printf(const char *format, ...) +std::ostream& operator<<(std::ostream& ostream, TimePeriod value) { - va_list arg; - va_start(arg, format); - vfprintf(stderr, format, arg); - va_end(arg); + return ostream << "( Duration:" << value.durationSeconds << " Delay:" << value.delaySeconds << ")"; } -/** - * DALI_TEST_CHECK is a wrapper for tet_result. - * If the condition evaluates to false, then the function & line number is printed. - * @param[in] The boolean expression to check - */ -#define DALI_TEST_CHECK(condition) \ -if ( (condition) ) \ -{ \ - tet_result(TET_PASS); \ -} \ -else \ -{ \ - fprintf(stderr, "%s Failed in %s at line %d\n", __PRETTY_FUNCTION__, __FILE__, __LINE__); \ - tet_result(TET_FAIL); \ +std::ostream& operator<<(std::ostream& ostream, Radian angle) +{ + ostream << angle.radian; + return ostream; } -bool operator==(TimePeriod a, TimePeriod b) +std::ostream& operator<<(std::ostream& ostream, Degree angle) { - return Equals(a.durationSeconds, b.durationSeconds) && Equals(a.delaySeconds, b.delaySeconds) ; + ostream << angle.degree; + return ostream; } -std::ostream& operator<< (std::ostream& o, const TimePeriod value) +std::ostream& operator<<(std::ostream& ostream, BaseHandle handle) { - return o << "( Duration:" << value.durationSeconds << " Delay:" << value.delaySeconds << ")"; + return ostream << static_cast(handle.GetObjectPtr()); } -void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, const char* location) +void DALI_TEST_EQUALS(const BaseHandle& baseHandle1, const BaseHandle& baseHandle2, const char* location) { - const float* m1 = matrix1.AsFloat(); - const float* m2 = matrix2.AsFloat(); - bool equivalent = true; + DALI_TEST_EQUALS(baseHandle1, baseHandle2, location); +} - for (int i=0;i<9;++i) +void DALI_TEST_EQUALS(const size_t value1, const uint32_t value2, const char* location) +{ + DALI_TEST_EQUALS((uint32_t)(value1), value2, location); +} + +void DALI_TEST_EQUALS(const uint32_t value1, const size_t value2, const char* location) +{ + DALI_TEST_EQUALS(value1, (uint32_t)(value2), location); +} + +void DALI_TEST_EQUALS(const Matrix3& matrix1, const Matrix3& matrix2, const char* location) +{ + const float* m1 = matrix1.AsFloat(); + const float* m2 = matrix2.AsFloat(); + bool equivalent = true; + + for(int32_t i = 0; i < 9; ++i) { - equivalent &= (m1[i] != m2[i]); + if(!(fabsf(m1[i] - m2[i]) < GetRangedEpsilon(m1[i], m2[i]))) + { + equivalent = false; + } } - if (!equivalent) + if(!equivalent) { + // Align each float to 1234.67, i.e. 3.6 will be " 3.60" + // clang-format off fprintf(stderr, "%s, checking\n" - "(%f, %f, %f) (%f, %f, %f)\n" - "(%f, %f, %f) == (%f, %f, %f)\n" - "(%f, %f, %f) (%f, %f, %f)\n", - location, - m1[0], m1[1], m1[2], m2[0], m2[1], m2[2], - m1[3], m1[4], m1[5], m2[3], m2[4], m2[5], - m1[6], m1[7], m1[8], m2[6], m2[7], m2[8]); + "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n" + "%7.2f %7.2f %7.2f == %7.2f %7.2f %7.2f\n" + "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n", + location, + m1[0],m1[3],m1[6],m2[0],m2[3],m2[6], + m1[1],m1[4],m1[7],m2[1],m2[4],m2[7], + m1[2],m1[5],m1[8],m2[2],m2[5],m2[8]); + // clang-format on tet_result(TET_FAIL); + throw("TET_FAIL"); } else { @@ -107,29 +135,33 @@ void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, const cha } } -void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, float epsilon, const char* location) +void DALI_TEST_EQUALS(const Matrix3& matrix1, const Matrix3& matrix2, float epsilon, const char* location) { - const float* m1 = matrix1.AsFloat(); - const float* m2 = matrix2.AsFloat(); - bool equivalent = true; + const float* m1 = matrix1.AsFloat(); + const float* m2 = matrix2.AsFloat(); + bool equivalent = true; - for (int i=0;i<9;++i) + for(int32_t i = 0; i < 9; ++i) { - equivalent &= (fabsf(m1[i] - m2[i]) 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(unsigned int value1, unsigned int value2, const char* location) -{ - if (!(value1 > value2)) + if(result) { - fprintf(stderr, "%s, checking %d > %d\n", location, value1, value2); - tet_result(TET_FAIL); + tet_result(TET_PASS); } else { - tet_result(TET_PASS); + tet_result(TET_FAIL); + throw("TET_FAIL"); } } -/** - * Test whether one float 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) +void DALI_TEST_EQUALS(const char* str1, const std::string& str2, const char* location) { - if (!(value1 > value2)) - { - fprintf(stderr, "%s, checking %f > %f\n", location, value1, value2); - tet_result(TET_FAIL); - } - else - { - tet_result(TET_PASS); - } + DALI_TEST_EQUALS(str1, str2.c_str(), location); } -void DALI_TEST_ASSERT( DaliException& e, std::string conditionSubString, const char* location ) +void DALI_TEST_ASSERT(DaliException& e, std::string conditionSubString, const char* location) { - if( NULL == strstr( e.condition, conditionSubString.c_str() ) ) + if(NULL == strstr(e.condition, conditionSubString.c_str())) { - fprintf(stderr, "Expected substring '%s' : actual exception string '%s' : location %s\n", conditionSubString.c_str(), e.condition, location ); + fprintf(stderr, "Expected substring '%s' : actual exception string '%s' : location %s\n", conditionSubString.c_str(), e.condition, location); tet_result(TET_FAIL); + throw("TET_FAIL"); } else { @@ -282,12 +299,12 @@ void DALI_TEST_ASSERT( DaliException& e, std::string conditionSubString, const c } // Functor to test whether an Applied signal is emitted -ConstraintAppliedCheck::ConstraintAppliedCheck( bool& signalReceived ) -: mSignalReceived( signalReceived ) +ConstraintAppliedCheck::ConstraintAppliedCheck(bool& signalReceived) +: mSignalReceived(signalReceived) { } -void ConstraintAppliedCheck::operator()( ActiveConstraint& constraint ) +void ConstraintAppliedCheck::operator()(Constraint& constraint) { mSignalReceived = true; } @@ -299,50 +316,74 @@ void ConstraintAppliedCheck::Reset() void ConstraintAppliedCheck::CheckSignalReceived() { - if ( !mSignalReceived ) + if(!mSignalReceived) { - fprintf(stderr, "Expected Applied signal was not received\n" ); - tet_result( TET_FAIL ); + fprintf(stderr, "Expected Applied signal was not received\n"); + tet_result(TET_FAIL); + throw("TET_FAIL"); } else { - tet_result( TET_PASS ); + tet_result(TET_PASS); } } void ConstraintAppliedCheck::CheckSignalNotReceived() { - if ( mSignalReceived ) + if(mSignalReceived) { - fprintf(stderr, "Unexpected Applied signal was received\n" ); - tet_result( TET_FAIL ); + fprintf(stderr, "Unexpected Applied signal was received\n"); + tet_result(TET_FAIL); + throw("TET_FAIL"); } else { - tet_result( TET_PASS ); + tet_result(TET_PASS); } } -BitmapImage CreateBitmapImage(int width, int height, const Vector4& color) +namespace Test { - BitmapImage image = BitmapImage::New(width, height, Pixel::RGBA8888); - - PixelBuffer* pixbuf = image.GetBuffer(); +struct ObjectDestructionFunctor +{ + // Create a ObjectDestructionFunctor passing in a Dali::RefObject* to be monitored and a bool variable. + // Create ObjectRegistry instance and connect to the ObjectDestroyedSignal passing in the above functor for the callback. + // Get the ObjectPointer (Actor::GetObjectPtr) of the Actor to be checked for destruction and assign it to the Dali::RefObject* + // Check the bool variable which would be true when object destroyed. + ObjectDestructionFunctor(Dali::RefObject* objectPtr, bool& refObjectDestroyed) + : refObjectPointerToCheck(objectPtr), + refObjectDestroyedBoolean(refObjectDestroyed) + { + refObjectDestroyed = false; + } - // Using a 4x4 image gives a better blend with the GL implementation - // than a 3x3 image - for(size_t i=0; i<16; i++) + void operator()(const Dali::RefObject* objectPointer) { - pixbuf[i*4+0] = color.r*255; - pixbuf[i*4+1] = color.g*255; - pixbuf[i*4+2] = color.b*255; - pixbuf[i*4+3] = color.a*255; + if(refObjectPointerToCheck == objectPointer) + { + refObjectDestroyedBoolean = true; + } } - return image; + Dali::RefObject* refObjectPointerToCheck; + bool& refObjectDestroyedBoolean; +}; + +ObjectDestructionTracker::ObjectDestructionTracker(ObjectRegistry objectRegistry) +: mObjectRegistry(objectRegistry), + mRefObjectDestroyed(false) +{ } -BitmapImage CreateBitmapImage() +void ObjectDestructionTracker::Start(Actor actor) { - return CreateBitmapImage(4, 4, Color::WHITE); + ObjectDestructionFunctor destructionFunctor(actor.GetObjectPtr(), mRefObjectDestroyed); + mObjectRegistry.ObjectDestroyedSignal().Connect(this, destructionFunctor); } + +bool ObjectDestructionTracker::IsDestroyed() +{ + return mRefObjectDestroyed; +} + +} // namespace Test