X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali-toolkit%2Fdali-toolkit-test-utils%2Fdali-test-suite-utils.cpp;h=b50f506489cb409a7e291584187ab3a240ec60a7;hb=0ade1ea02b460b002d9cd82cd3023a5107eb6294;hp=cc16ab016eeee53f32de3a9010ac7d5aae5c34f4;hpb=928136dbb9e23970f3894eabc7c8b224003b77be;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git 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 cc16ab0..b50f506 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) 2015 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,11 +15,14 @@ * */ +// CLASS HEADER +#include "dali-test-suite-utils.h" + +// EXTERNAL INCLUDES +#include + // INTERNAL INCLUDES #include -#include - -#include "dali-test-suite-utils.h" using namespace Dali; @@ -51,30 +54,41 @@ void tet_printf(const char *format, ...) va_end(arg); } -/** - * 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); \ -} - bool operator==(TimePeriod a, TimePeriod b) { return Equals(a.durationSeconds, b.durationSeconds) && Equals(a.delaySeconds, b.delaySeconds) ; } -std::ostream& operator<< (std::ostream& o, const TimePeriod value) +std::ostream& operator<<( std::ostream& ostream, TimePeriod value ) +{ + return ostream << "( Duration:" << value.durationSeconds << " Delay:" << value.delaySeconds << ")"; +} + +std::ostream& operator<<( std::ostream& ostream, Radian angle ) +{ + ostream << angle.radian; + return ostream; +} + +std::ostream& operator<<( std::ostream& ostream, Degree angle ) +{ + ostream << angle.degree; + return ostream; +} + +void DALI_TEST_EQUALS( const BaseHandle& baseHandle1, const BaseHandle& baseHandle2, const char* location ) +{ + DALI_TEST_EQUALS< const BaseHandle& >( baseHandle1, baseHandle2, location ); +} + +void DALI_TEST_EQUALS( const size_t value1, const unsigned int value2, const char* location ) { - return o << "( Duration:" << value.durationSeconds << " Delay:" << value.delaySeconds << ")"; + DALI_TEST_EQUALS< unsigned int>( ( unsigned int )( value1 ), value2, location ); +} + +void DALI_TEST_EQUALS( const unsigned int value1, const size_t value2, const char* location ) +{ + DALI_TEST_EQUALS< unsigned int >( value1, ( unsigned int )( value2 ), location ); } void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, const char* location) @@ -85,10 +99,13 @@ void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, const cha for (int 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 ) { fprintf(stderr, "%s, checking\n" "(%f, %f, %f) (%f, %f, %f)\n" @@ -216,56 +233,30 @@ void DALI_TEST_EQUALS( const std::string &str1, const char* str2, const char* lo DALI_TEST_EQUALS(str1.c_str(), str2, location); } -/** - * 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_EQUALS( const char* str1, const std::string &str2, const char* location) +void DALI_TEST_EQUALS( Property::Value& str1, const char* str2, const char* location) { - DALI_TEST_EQUALS(str1, str2.c_str(), location); -} + bool result = false; + if( str1.GetType() == Property::STRING ) + { + std::string string; + str1.Get(string); + result = !string.compare(str2); + } -/** - * 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(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); } } -/** - * 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 ) @@ -287,7 +278,7 @@ ConstraintAppliedCheck::ConstraintAppliedCheck( bool& signalReceived ) { } -void ConstraintAppliedCheck::operator()( ActiveConstraint& constraint ) +void ConstraintAppliedCheck::operator()( Constraint& constraint ) { mSignalReceived = true; } @@ -346,3 +337,51 @@ BufferImage CreateBufferImage() { return CreateBufferImage(4, 4, Color::WHITE); } + +namespace Test +{ + +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; + } + + void operator()( const Dali::RefObject* objectPointer ) + { + if ( refObjectPointerToCheck == objectPointer ) + { + refObjectDestroyedBoolean = true; + } + } + + Dali::RefObject* refObjectPointerToCheck; + bool& refObjectDestroyedBoolean; +}; + +ObjectDestructionTracker::ObjectDestructionTracker() + :mRefObjectDestroyed( false) +{ +} + +void ObjectDestructionTracker::Start( Actor actor ) +{ + ObjectDestructionFunctor destructionFunctor( actor.GetObjectPtr(), mRefObjectDestroyed ); + + ObjectRegistry objectRegistry = Stage::GetCurrent().GetObjectRegistry(); + objectRegistry.ObjectDestroyedSignal().Connect( this, destructionFunctor ); +} + +bool ObjectDestructionTracker::IsDestroyed() +{ + return mRefObjectDestroyed; +} + +} // namespace Test