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=64f576e5dcae5be8e46fa26abe5d95bd83fbe8c5;hb=fede1dfcd3dee5076f26cb48d009f2375944e467;hpb=30f6ca1e541089b19f2b349a8a12d8a5bcaf2f9e 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 64f576e..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,104 +1,133 @@ -// -// Copyright (c) 2014 Samsung Electronics Co., Ltd. -// -// Licensed under the Flora License, Version 1.0 (the License); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://floralicense.org/license/ -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an AS IS BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// - -// INTERNAL INCLUDES -#include -#include +/* + * 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ +// CLASS HEADER #include "dali-test-suite-utils.h" +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + 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_printf(const char* format, ...) + { + va_list arg; + va_start(arg, format); + vfprintf(stderr, format, arg); + va_end(arg); + } +} -void tet_infoline(const char* str) +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); +} + +void DALI_TEST_EQUALS(const size_t value1, const uint32_t value2, const char* location) +{ + DALI_TEST_EQUALS((uint32_t)(value1), value2, location); +} - for (int i=0;i<9;++i) +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 { @@ -106,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); } -/** - * Test whether the assertion condition that failed and thus triggered the - * exception \b e contained a given substring at the start of its literal text. - * @param[in] e The exception that we expect was fired by a runtime assertion - * failure. - * @param[in] conditionSubString The text that we expect to be present in an - * assertion which triggered the exception. - * @param[in] location The TEST_LOCATION macro should be used here. - * - * @remark **Side-effects:** The result of the tet test is set to TET_PASS if - * the substring is at the start of the exception's condition and - * TET_FAIL if it isn't. Note, if the result of a test is set multiple - * times, a TET_FAIL will override any number of TET_PASSes. - */ -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( 0u != e.mCondition.find( conditionSubString )) + if(NULL == strstr(e.condition, conditionSubString.c_str())) { - fprintf(stderr, "Assertion %s failed at %s\n", conditionSubString.c_str(), 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 { @@ -294,21 +298,13 @@ void DALI_TEST_ASSERT( DaliException& e, std::string conditionSubString, const c } } -/** Self-documenting wrapper for DALI_TEST_ASSERT. - * @copydoc DALI_TEST_ASSERT() - */ -void DALI_TEST_ASSERT_CONDITION_STARTS_WITH_SUBSTRING( DaliException& exceptionFromAssertion, std::string conditionSubString, const char* location ) -{ - DALI_TEST_ASSERT(exceptionFromAssertion, conditionSubString, location); -} - // 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; } @@ -320,51 +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