#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.
*
*/
+// EXTERNAL INCLUDES
+#include <cstdarg>
+#include <iostream>
+
// INTERNAL INCLUDES
#include <dali/public-api/dali-core.h>
-#include <stdarg.h>
void tet_infoline(const char*str);
void tet_printf(const char *format, ...);
#include "test-application.h"
+#include "test-actor-utils.h"
using namespace Dali;
/**
* 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) \
{ \
fprintf(stderr, "%s Failed in %s at line %d\n", __PRETTY_FUNCTION__, __FILE__, __LINE__); \
tet_result(TET_FAIL); \
+ throw("TET_FAIL"); \
}
template <typename Type>
template <>
inline bool CompareType<Radian>(Radian q1, Radian q2, float epsilon)
{
- return CompareType<float>(float(q1), float(q2), epsilon);
+ return CompareType<float>(q1.radian, q2.radian, epsilon);
}
template <>
inline bool CompareType<Degree>(Degree q1, Degree q2, float epsilon)
{
- return CompareType<float>(float(q1), float(q2), epsilon);
+ return CompareType<float>(q1.degree, q2.degree, epsilon);
+}
+
+template <>
+inline bool CompareType<Property::Value>(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<float>(a, b, epsilon);
+ break;
+ }
+ case Property::VECTOR2:
+ {
+ Vector2 a, b;
+ q1.Get(a);
+ q2.Get(b);
+ return CompareType<Vector2>(a, b, epsilon);
+ break;
+ }
+ case Property::VECTOR3:
+ {
+ Vector3 a, b;
+ q1.Get(a);
+ q2.Get(b);
+ return CompareType<Vector3>(a, b, epsilon);
+ break;
+ }
+ case Property::RECTANGLE:
+ case Property::VECTOR4:
+ {
+ Vector4 a, b;
+ q1.Get(a);
+ q2.Get(b);
+ return CompareType<Vector4>(a, b, epsilon);
+ break;
+ }
+ case Property::ROTATION:
+ {
+ Quaternion a, b;
+ q1.Get(a);
+ q2.Get(b);
+ return CompareType<Quaternion>(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.
* @param[in] value2 The second value
* @param[in] location The TEST_LOCATION macro should be used here
*/
-template<typename TypeA, typename TypeB>
-inline void DALI_TEST_EQUALS(TypeA value1, TypeB value2, const char* location)
+template<typename Type>
+inline void DALI_TEST_EQUALS(Type value1, Type value2, const char* location)
{
if (!(value1 == value2))
{
}
}
+template<typename Type>
+inline void DALI_TEST_NOT_EQUALS(Type value1, Type value2, float epsilon, const char* location)
+{
+ if( CompareType<Type>(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
}
/**
+ * 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
* @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.
* @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
struct ConstraintAppliedCheck
{
ConstraintAppliedCheck( bool& signalReceived );
- void operator()( ActiveConstraint& constraint );
+ void operator()( Constraint& constraint );
void Reset();
void CheckSignalReceived();
void CheckSignalNotReceived();
};
-// Helper to Create bitmap image
-BitmapImage CreateBitmapImage();
-BitmapImage CreateBitmapImage(int width, int height, const Vector4& color);
+// 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__
projects / platform / core / uifw / dali-toolkit.git / blobdiff